elxr/index.js

var path = require('path');
var utils = require('bbhverse');
var any = utils.any;              
var Tasq = utils.Tasq
var statuslog = utils.Traq
var Traq = utils.Traq
Tasq.addlistener(statuslog.statuslog) 


function nodeShellExec() {

  var args = Array.from(arguments);
  var opts = args[2] = args[2] || {}
  opts.title ? null : opts.title = `${args[0]} ${args[1]  }`
  const child = spawn(...arguments);

  var p = new Promise(function(resolve, reject){
    if(!opts.detached) {
      var messages = []; // PB : TODO -- Explore stream for Task level  aggregation to prevent interleaved messages from multiple tasks...
      var success = true;
      
      if(opts.stdio !== 'ignore') {
        child.stdout.setEncoding('utf8');
        child.stderr.setEncoding('utf8');
        child.stdout.on('data', (chunk) => { chunk.trim() === '' ? null : messages.push(chunk); /* console.log('d: ' + chunk) */ });
        child.on('error', (chunk) => { success = false; messages.push(chunk); /* console.error('e: ' + chunk) */ }  );
        child.stderr.on('data', (chunk) => { 
          if(messages.join('').indexOf('fatal: not a git repository') > -1) opts.haserrors = true; 
          messages.push(chunk); 
          // console.error('stderr e: ' + chunk)
        });
      }
      child.on('close', (code) => {
        if(+code !== 0 || opts.haserrors) success = false;
        if(opts.stdio !== 'ignore') {
          var logEntry = { result: `${opts.title} exited with code ${code}`, messages }
          logEntry.success = success;

          if(opts.runas){
            // success ? logEntry.success = true : null;
            fs.writeFileSync('run.log', ', ' + JSON.stringify(logEntry), {'flag':'a+'} )
          }
          else {
            // console.log( messages.join('') )
            process.stdout.write( messages.join('') )
          }
        }
        if(code !== 0 || opts.haserrors) return reject(logEntry)
        resolve(logEntry)
      });
    }
    else {
      child.unref()
      resolve(true);
    }
  });
  p.process = child; 
  return p;
}


// 'use strict';

// PB : TODO -- make sure folder context is proper coz we can now run elxr from anywhere.

// --------------
// elxr 
//   A cli tool for elixr.

// PB : TODO -- 
// runas bypass non elevated tasks when we request privelege
// runas message is always error needs to be fixed.
// runas wait needs to be parallelized.
// suppress elevation check error messages
// support runas lauched directly from shell.
// pass in environment in hta to shellexecute.

const { existsSync } = require('fs');
const fs = require('fs')
const { spawn, spawnSync } = require('child_process');
const cliargs = utils.cliargs;
const processedArgs = cliargs(process.argv.slice(2));
console.dir(processedArgs)
var globSync = require('glob').sync;

var path = require('path');
const { isMaster } = require('cluster');


var getPullCmd = (repo)=>{
  // console.log(useGitPull)

  var pullCmd = [ gitInstallDir
    , ['-c', 'for i in `git remote`; do git pull $i master; done;']
    , { cwd : repo, title : 'pull all origins for ' + repo }]
  // var pullCmd = ['pullall', [], { cwd : repo }]
  if(useGitPull) pullCmd = ['git', ['pull'], {
    inherit : true, shell: true, 
    cwd : repo
    // , env: process.env
    , runas : processedArgs.runas
    , title : `git pull ${repo}`
  }]
  return pullCmd
}

var getCmd = (command, args, options)=>{
  return [command, args, Object.assign({
      inherit : true, shell: true, title : `${command} ` 
    }, options)
  ]
}

var performPull = (repo) => { 

  if(exludeMergeRepos[repo]) return Promise.resolve({ 'skipped' : true })


  if(existsSync(repo)) {
    console.log('pulling ' + repo)
    return nodeShellExec.apply(null, getPullCmd(repo)).catch((e)=>{ console.error(e) }) 
  }
  else {
    console.log('cloning ' + repo)
    // PB : TODO -- detect if a clonable repo exists in currentGitAuthUser
    return nodeShellExec('git', ['clone', '-c', 'core.symlinks=true', defaultRepoServer + `/${defaultRepoOwner}/` + repo + '.git'],
    {
      inherit : true, shell: true, 
        env: process.env
      , runas : processedArgs.runas
    }).catch((e)=>{ console.error(e) }).then(()=>{

      return nodeShellExec('git', ['config', '--replace-all' , 'core.symlinks', true],
      {
        inherit : true, shell: true, 
          env: process.env
        , cwd : repo
        , runas : processedArgs.runas
        , title : `git core.symlinks --replace-all true for ${defaultRepoServer + `/${defaultRepoOwner}/` + repo + '.git'}`
      })
    })
  }
}

try {

  // Default Config...
  var reposervers = [
    'http://git.bbh'
  , 'https://git.bbh.org.in'
  , '//172.16.0.27/repos'
  ]
  var defaultRepoServer = reposervers[0]

  var currentGitAuthUser ; // nodeShellExec('git', ['config', 'user.email']) ... PB : TODO-- get the current gittea username 
  var defaultRepoOwner = 'chess'; 

  var cli = 'elxr';
  var ver = '#unversioned'; 
  var help = '#unkown list of commands... please refer dveloper documentation for ' + cli;

  // grep -qxF 'alias elxr="node elxr/index.js"'  ~/.bash_profile || echo 'alias elxr="node elxr/index.js"' >> ~/.bash_profile


  // nodeShellExec('echo', ['elxr'], { inherit : true}) //, {stdio: "inherit"}

  var dbForLabel = function(label){
    var dbsForLabel = {
        devmysql : 'mysql'
      , development : 'mssql'
      , production : 'mssql'
    }
    return dbsForLabel[label] || 'mysql'
  }

  var gitInstallDir = "C:\\Program Files\\Git\\bin\\sh.exe"
  // var gitInstallDir = "G:\\Installed\\Git\\bin\\sh.exe"
  // Relevant git repos

  var brandName = 'elixir';
  // Runas windowshta clobbers and removes the NODE_ENV !!! We therefore pass it in.
  var nodeenv = (process.env.NODE_ENV && process.env.NODE_ENV.trim())  || processedArgs.node_env || 'development'

  // var repomanifest = require('../'+brandName+'-config-'+ nodeenv +'/repo-manifest')()
  var exludeMergeRepos = [];
  var useGitPull = processedArgs.useGitPull || false;

  var configrepo = brandName+'-config-'+nodeenv
  var configpath = '../' + configrepo;
  var configPromise = null

  if(!existsSync(configpath)){ configPromise = performPull(configrepo) }
  else configPromise = Promise.resolve(true)

  configPromise.then(()=>{

    // PB : TODO -- If we are run from an elevated shell it never moves forward and simply exits.
    // -- Currently workaround is to always run from a non-elevated shell.
    var __isElevated = null; // We assume non-Elevated until someone evaluates and sets this variable.
    var isRunningElevated = ()=>{
        if(__isElevated === null) {
          return nodeShellExec( "fsutil", ["dirty", "query", "C:"], { 
            inherit : true
            // , shell: true
              , stdio: 'ignore'
              , env: process.env
              , title : `check privileged execution mode using "fsutil dirty query C:"`
          }).then((exitcode)=>{    
            console.log('Elevated')
            __isElevated = true;
            return true;
          }).catch(()=>{
            __isElevated = false;
            console.log('Not Elevated');
            return false;
          });
        }
        else return Promise.resolve(__isElevated);
    }

    isRunningElevated().then(()=>{
      // Everything runs after this check is completed. Elevation occurs out of process when needed.
      
      var manifestpath = '../'+brandName+'-config-'+nodeenv+'/repo-manifest';
      // var manifestpath = '../'+brandName+'-config-'+'production'+'/repo-manifest';
      // console.dir(manifestpath)
      var repomanifest = require(manifestpath)()
      // console.dir(repomanifest)

      var gitRepos = repomanifest.repos

      // Repositiories that have symlinks that required elevated priviletes in windows to create symlinks
      // 
      var elevatedRunasRepos = repomanifest.elevated

      exludeMergeRepos = repomanifest.exludeMergeRepos

      // var productionRepos = [ 'elixir-config-production' ]
      // var productionIsAllowed = (nodeenv === 'production');
      // if(productionIsAllowed) gitRepos = gitRepos.concat(productionRepos)

      var env = Object.assign({}, process.env); // Shallow clone it.
      var __runcmd = function(label){

        var op = {
            'h' : ()=>{ console.log(cli + ' ' + ver + ' ' + help); return '-h' }
          , 'undefined' : ()=>{ return op.h(); }
          , 'reset' : ()=>{
            
            // Reset NPM packages semver so major versions can be updated.
            
            const fs = require('fs')
            const wipeDependencies = (package) => {
              const file  = fs.readFileSync(package + '/package.json')
              const content = JSON.parse(file)
              for (var devDep in content.devDependencies) {
                if (content.devDependencies[devDep].match(/\W+\d+.\d+.\d+-?((alpha|beta|rc)?.\d+)?/g)) {
                  content.devDependencies[devDep] = '*';
                }
              }
              for (var dep in content.dependencies) {
                if (content.dependencies[dep].match(/\W+\d+.\d+.\d+-?((alpha|beta|rc)?.\d+)?/g)) {
                  content.dependencies[dep] = '*';
                }
              }
              fs.writeFileSync(package + '/package.json', JSON.stringify(content))
            }

            var repos = ['client'];
            // repos = gitRepos;
            repos.forEach(wipeDependencies)
            // if (require.main === module) {
            // } else {
            //   module.exports = wipeDependencies
            // }

          }
          , 'upgrade' : ()=>{
            console.log('upgrade.......')
            var tasks = [
              ()=>{ 
                var p = nodeShellExec('npm', ['i', '-g', 'npm-upgrade'], {
                  inherit : true, shell: true
                      , env: process.env
                }).catch((e)=>{ console.error(e) }) 
                p.position = 1;
                console.log('One')
                return p;
              }
              , ()=>{ 
                var p = nodeShellExec('npm', ['cache', 'clean', '-f'], {
                  inherit : true, shell: true
                      , env: process.env
                }).catch((e)=>{ console.error(e) }) 
              
                p.position = 2;
                console.log('Two')
                return p;
              }
              , ()=>{ 
                var p = nodeShellExec('npm', ['install', '-g', 'n'], {
                  inherit : true, shell: true
                      , env: process.env
                }).catch((e)=>{ console.error(e) }) 
                p.position = 3;
                console.log('Three')
                return p;
              }
              , ()=>{ 
                var p = nodeShellExec('n', ['latest'], {
                  inherit : true, shell: true
                      , env: process.env
                }).catch((e)=>{ console.error(e) }) 
                p.position = 4;
                console.log('Four')
                return p;
              }
            ]
            any(tasks)
            console.log('.......done')
            console.log('Running exlr upgrade in : ' + path.dirname(__dirname))
            console.log('Currently only upgrades ember : ' + path.dirname(__dirname));
            console.info('Uninstalling existing ember globally') ;
            var step1 = nodeShellExec('cmd', ['/c', 'npm', 'uninstall', '-g', 'ember-cli'], {
                stdio: ['pipe', process.stdout, process.stderr],
                inherit : true,
                shell: true,
                cwd : path.dirname(__dirname),
                env: env
              })
              step1.on('close', ()=>{
                console.info('Installing ember globally') ;
                var step2 = nodeShellExec('cmd', ['/c', 'npm', 'install', '-g', 'ember-cli'], {
                  stdio: ['pipe', process.stdout, process.stderr],
                  inherit : true,
                  shell: true,
                  cwd : path.dirname(__dirname),
                  env: env
                })
                
                step2.on('close', ()=>{
                  nodeShellExec('cmd', ['/c', 'ember', '--version'], {
                    stdio: ['pipe', process.stdout, process.stderr],
                    inherit : true,
                    shell: true,
                    cwd : path.dirname(__dirname),
                    env: env
                  })
                })
              })
            }
          , 'runas' : ()=>{
            console.log('Testing Elevation')

            if(__isElevated){
              try { 
                op[ processedArgs.label || processedArgs._[0] || 'h']()
              }
              catch(e){ 
                console.error('Error Invalid command : ' + e) 
                fs.writeFileSync('run.done', 'error')
              }
              finally {
              }
            }
            else {
              console.log('Requesting Elevated Privileges');
              // Wait for the runas to complete before we read it.
              try {
                fs.unlinkSync('run.done')
                fs.unlinkSync('run.log')
              }
              catch(e) { } //Ignore 
              
              // Find node path to send to hta.
              return nodeShellExec('where', ['node']).then(r => {
                console.log('result : ' + JSON.stringify(r))
                // throw 'rrrrrrrrrrrrrrrrr'
                // PB : TODO -- Convert all the cli args back to string.
                var namedArgs = [];
                Object.keys(processedArgs).forEach((v)=>{ v!='_' ? namedArgs.push('--'+v+'='+processedArgs[v]) : null; })
                //console.log(' namedArgs : ' + namedArgs)
                var env = Object.assign({}, process.env); // Shallow clone it.
                // console.dir(env)
                env.NODE_ENV = process.env.NODE_ENV || 'development';
                var args = [__dirname + '/windowselevate.hta'].concat(processedArgs._).concat(namedArgs.join(' ')); args.push('--runas=self');
                args.push('--nodepath='+r[r.length-1])
                args.push('--node_env='+env.NODE_ENV)
                args.push('--debug=true') // Enable to debug elevated..



                return nodeShellExec('MSHTA', [`"${args.join('" "')}"`]
                  , {
                      inherit : true
                    , shell: true
                    , env: env
                    , runas : 'self'
                    , title : `runas`
                  }
                ).then(()=>{
                  // runas returned.
                  try {
                    // PB : TODO -- Log is comma prefixed. Needs to be proper JSON.
                    var runaslog = JSON.parse('[ { "success" : true, "result" : "started"}' + fs.readFileSync('run.log', { flags : 'a+'}) + ']');
                    runaslog.forEach((logEntry)=>{
                      statuslog.statuslog(logEntry.success ? null : logEntry, logEntry)
                      logEntry.success ? (console.log(['success :' + logEntry.result]), console.log((logEntry.messages || []).join(' '))) : (console.error(['error :' + logEntry.result]), console.error((logEntry.messages || []).join(' ')))
                    })  
                  }
                  catch(e){
                    // We must have a runas log
                    statuslog.statuslog(e)
                    console.error('Run log error probably was not created by runas : ' + e)
                  }
                })
                .catch(err => console.error('Elevation failed : ' + err));
              })

            }
          }
          , 'push' : ()=>{
            if(!processedArgs._[1]) { console.error('push all not supported. Specify repo name'); return }
            // init remote bare from local
            // pushandinitremotebare
            // https://www.jeffgeerling.com/blogs/jeff-geerling/push-your-git-repositories
            // connect to repo server -- net use 172.16.0.27 
            // cd 172.16.0.27/repos/
            // mkdir repo.git
            // cd repo.git
            // git init --bare
            // cd localrepo
            // git remote rename origin githubclone
            // git remote add origin //172.16.0.27/repos/repo.git
            // git push origin master

            var repo = processedArgs._[1];
            
            var sequentialTaskShellCommands = [];
            if(!existsSync(`Z:/${repo}.git`)){
              sequentialTaskShellCommands = [
                // ['net', ['use', 'Z:', defaultRepoServer.replace('/','\\')], {
                //   inherit : true, shell: true
                //   , env: process.env
                // }]
                  ['pwd', { cwd : 'Z:', inherit : true}]
                , ['mkdir', [`${repo}.git`], {
                    cwd : `Z:`
                    , inherit : true, shell: true
                    , env: process.env
                }]
                , ['pwd', { cwd : `Z:/${repo}.git`, inherit : true}]
                , ['git', ['init', '--bare'], { cwd : `Z:/${repo}.git`
                    , inherit : true, shell: true
                    , env: process.env
                }]
                // PB : TODO -- Do this conditionally only...
                , ['git', ['remote', 'rename', 'origin', 'githubclone'], { cwd : `${repo}`}, (err)=>{
                  console.log('Ignoring origin rename error : ' + err); return true; //return true to continue.
                } ] // PB ; Todo -- new repositories created locally will not have origin. Handle this failure.
                , ['git', ['remote', 'add', 'origin', `${defaultRepoServer}/${repo}.git`], { cwd : `${repo}`}]
                // PB : TODO -- If threre is a gitbubclone origin 
                  // Set the master to pull from the local repo.
              ]
              if(!existsSync(`Z:`)){
                sequentialTaskShellCommands.splice(0,0, ['net', ['use', 'Z:', defaultRepoServer.replace(/\//gm,'\\')], {
                  inherit : true, shell: true
                  , env: process.env
                }])
                console.warn('Adding network drive z: for repo server. ' + sequentialTaskShellCommands[0])
                // throw 'done'
              }
            }
            
            sequentialTaskShellCommands.push(['git', ['push', 'origin', 'master'], { cwd : `${repo}`}])
            // console.dir(sequentialTaskShellCommands);

            var tasks = [];
            sequentialTaskShellCommands.forEach(shellcmd => {
              // console.log(shellcmd)
              tasks.push(()=>{ 
                
                var p = nodeShellExec.apply(null, shellcmd.slice(0,3)).catch((e)=>{ if(shellcmd[3]) { return shellcmd[3]() } else { console.error(e);}  })
                return p; 
              })
            })
            any(tasks);

          }
          , 'is-git-repo' : (dir)=>{
            return nodeShellExec('git', ['-C', dir.name, 'rev-parse'], { stdio : 'ignore'})
          }
          , 'set-url' : (remotename, url) => {
            var pushable = processedArgs.pushable || false;
            remotename = remotename || processedArgs._[1]
            url = url || processedArgs._[2]
            var serial_perform_git_seturl = (repo)=>{
              var options = {  cwd : repo }
              // console.log(repo)
              if(pushable) {
                return [
                  ['git', ['remote', 'set-url', remotename, url + '/' + repo], {  cwd : repo }]
                ]
              }
              else {
                console.error('not supported for non-pushable')
              }

            }
            var x = (args)=>{
              return ()=>{
                // console.log(args)
                return nodeShellExec.apply(null, args)
              }
              // return Promise.resolve(true)
            }
            var perform_git_seturl = (dir)=>{
              op['is-git-repo'](dir).then((code)=>{
                any( serial_perform_git_seturl(dir.name).map(x) )                        
              }).catch((e)=>{
                // console.log('Failed : ' + dir.name)
              })
            }

            const { readdir } = require("fs").promises

            const dirs = async (perform, path) => {
              for (const dir of await readdir(path || process.cwd(), { withFileTypes: true })) {
                if (dir.isDirectory()) perform(dir)
              }
            }

            dirs( perform_git_seturl)
          }
          , 'add' : (remotename, url, branch) => {
            var pushable = processedArgs.pushable || false;
            remotename = remotename || processedArgs._[1]
            url = url || processedArgs._[2]
            branch = branch || processedArgs._[3]
            var serial_perform_git_add = (repo)=>{
              var options = {  cwd : repo }
              // console.log(repo)
              if(pushable) {
                return [
                  ['git', ['remote', 'add', remotename, url + '/' + repo], {  cwd : repo }]
                  , ['git', ['pull', remotename, branch], {  cwd : repo }]
                  , ['git', ['branch', `--set-upstream-to=${remotename}/${branch}`, branch], {  cwd : repo }]
                ]
              }
              else {

                return [
                  ['git', ['remote', 'add', remotename, url + '/' + repo], {  cwd : repo }]
                  , ['git', ['remote', `set-url`, '--push', remotename, 'no-pushing'], {  cwd : repo }]
                  , ['git', ['pull', remotename, branch], {  cwd : repo }]
                  , ['git', ['branch', `--set-upstream-to=${remotename}/${branch}`, branch], {  cwd : repo }]
                ]
              }

            }
            var x = (args)=>{
              return ()=>{
                // console.log(args)
                return nodeShellExec.apply(null, args)
              }
              // return Promise.resolve(true)
            }
            var perform_git_add = (dir)=>{
              op['is-git-repo'](dir).then((code)=>{
                // console.log(code)
                if(code) {
                  nodeShellExec('git',['remote', 'get-url', remotename], { cwd : dir.name, stdio : 'ignore' }).then(()=>{
                    console.log('skipped : ' + dir.name + ', reason : A remote with same name already exists.')
                  })
                  .catch((e)=>{
                    any( serial_perform_git_add(dir.name).map(x) )            
                  })
                }
                // else console.log('Skipped : Not a Git Repo : ' + dir.name)
              }).catch((e)=>{
                // console.log('Failed : ' + dir.name)
              })
            }

            const { readdir } = require("fs").promises

            const dirs = async (perform, path) => {
              for (const dir of await readdir(path || process.cwd(), { withFileTypes: true })) {
                if (dir.isDirectory()) perform(dir)
              }
            }

            dirs(perform_git_add)
          }
          , 'remove' : (remotename) => {
            remotename = remotename || processedArgs._[1]
            var serial_perform_git_remove = (repo)=>{
              var options = {  cwd : repo }
              // console.log(repo)
              return [
                ['git', ['remote', 'remove', remotename], {  cwd : repo }]
              ]
            }
            var x = (args)=>{
              return ()=>{
                // console.log(args)
                return nodeShellExec.apply(null, args)
              }
              // return Promise.resolve(true)
            }
            var perform_git_remove = (dir)=>{
              op['is-git-repo'](dir).then((code)=>{
                // console.log(code)
                if(code) {
                  nodeShellExec('git',['remote', 'get-url', remotename], { cwd : dir.name, stdio : 'ignore' }).then(()=>{
                    any( serial_perform_git_remove(dir.name).map(x) )            
                  })
                  .catch((e)=>{
                    console.log('skipped : ' + dir.name + ', reason : No remote named origin')
                  })
                }
                // else console.log('Skipped : Not a Git Repo : ' + dir.name)
              }).catch((e)=>{
                // console.log('Failed : ' + dir.name)
              })
            }

            const { readdir } = require("fs").promises

            const dirs = async (perform, path) => {
              for (const dir of await readdir(path || process.cwd(), { withFileTypes: true })) {
                if (dir.isDirectory()) perform(dir)
              }
            }

            dirs(perform_git_remove)
          }
          , 'init-gitea' : (user) => {
            user = user || processedArgs._[1]
            if(!user) throw 'User name required'
            var serial_perform_init_gitea = (repo)=>{
              var options = {  cwd : repo }
              // console.log(repo)
              return [
                ['git', ['remote', 'add', 'chess', `${defaultRepoServer}/${user}/${repo}.git`], {  cwd : repo }]
              , ['git', ['remote', 'set-url', '--push', 'chess', 'no-pushing'], {  cwd : repo }]
              , ['git', ['remote', 'set-url', 'origin', `${defaultRepoServer}/${user}/${repo}.git`], {  cwd : repo }]
            ]}
            var x = (args)=>{
              return ()=>{
                // console.log(args)
                return nodeShellExec.apply(null, args)
              }
              // return Promise.resolve(true)
            }
            var perform_init_gitea = (dir)=>{
              op['is-git-repo'](dir).then((code)=>{
                // console.log(code)
                if(code) {
                  nodeShellExec('git',['remote', 'get-url', 'chess'], { cwd : dir.name, stdio : 'ignore' }).then(()=>{
                    console.log('skipped : ' + dir.name + ', reason : Already has remote chess ')
                  })
                  .catch((e)=>{
                    any( serial_perform_init_gitea(dir.name).map(x) )            
                  })
                }
                // else console.log('Skipped : Not a Git Repo : ' + dir.name)
              }).catch((e)=>{
                // console.log('Failed : ' + dir.name)
              })
            }

            const { readdir } = require("fs").promises

            const dirs = async (perform, path) => {
              for (const dir of await readdir(path || process.cwd(), { withFileTypes: true })) {
                if (dir.isDirectory()) perform(dir)
              }
            }

            dirs(perform_init_gitea)
          }
          , 'syncmaster' : (label) => {
            // Usage :
            // elxr pull -- Defaults to run config
            
            var env = Object.assign({}, process.env); // Shallow clone it.
            // console.dir(env)
            console.log('Running exlr pull : ' + path.dirname(__dirname))
            
            if(!processedArgs.runas) gitRepos.forEach(performPull)
            if(__isElevated){
              return any(elevatedRunasRepos.map((repo)=>performPull(repo))).then(()=>{
                fs.writeFileSync('run.done', 'success')
              }).catch(()=>{
                fs.writeFileSync('run.done', 'error')
              })
            }
            else return op['runas']()
          }

          , 'pull' : (label) => {
            // Usage :
            // elxr pull -- Defaults to run config
            
            var env = Object.assign({}, process.env); // Shallow clone it.
            console.log('Running exlr pull : ' + path.dirname(__dirname))

            var useGitPull = processedArgs.useGitPull || false;
            var getPullCmd = (repo)=>{
              // console.log(useGitPull)

              var pullCmd = [ gitInstallDir
                , ['-c', 'branch=`git rev-parse --abbrev-ref HEAD`;for i in `git remote`; do git pull $i $branch; done;']
                , { cwd : repo, title : 'pull all origins for ' + repo }]
              // var pullCmd = ['pullall', [], { cwd : repo }]
              if(useGitPull) pullCmd = ['git', ['pull'], {
                inherit : true, shell: true, 
                cwd : repo
                // , env: process.env
                , runas : processedArgs.runas
                , title : `git pull ${repo}`
              }]
              return pullCmd
            }

            var performPull = (repo) => {
              if(existsSync(repo)) {
                console.log('pulling ' + repo)
                return nodeShellExec.apply(null, getPullCmd(repo)).then(()=>{ 
                    if(__isElevated) {
                      fs.writeFileSync('run.log', ', ' + JSON.stringify({ repo, success:true}), {'flag':'a+'} )
                    }
                    else statuslog.statuslog(null, repo)
                    return true;
                  })
                  .catch((e)=>{ 
                    e.repo = repo;
                    if(__isElevated) {
                      fs.writeFileSync('run.log', ', ' + JSON.stringify(e), {'flag':'a+'} )
                    }
                    else statuslog.statuslog(e); console.error(e)
                  }) 
              }
              else {
                // PB : TODO -- detect if a clonable repo exists in currentGitAuthUser
                return nodeShellExec('git', ['clone', '-c', 'core.symlinks=true', defaultRepoServer + `/${defaultRepoOwner}/` + repo + '.git'],
                {
                  inherit : true, shell: true, 
                    env: process.env
                  , runas : processedArgs.runas
                }).catch((e)=>{ 
                  throw e;
                }).then(()=>{

                  return nodeShellExec('git', ['config', '--replace-all' , 'core.symlinks', true],
                  {
                    inherit : true, shell: true, 
                      env: process.env
                    , cwd : repo
                    , runas : processedArgs.runas
                    , title : `git core.symlinks --replace-all true for ${defaultRepoServer + `/${defaultRepoOwner}/` + repo + '.git'}`
                  })
                  .then(()=>{
                    if(__isElevated) {
                      fs.writeFileSync('run.log', ', ' + JSON.stringify({ repo, success:true}), {'flag':'a+'} )
                    }
                    else statuslog.statuslog(null, repo)
                  })
                  .catch((e)=>{
                    e.repo = repo;
                    if(__isElevated) {
                      fs.writeFileSync('run.log', ', ' + JSON.stringify(e), {'flag':'a+'} )
                    }
                    else statuslog.statuslog(e);
                  })
                })
                .catch(e=>{ 
                  e.repo = repo;
                  if(__isElevated) {
                    fs.writeFileSync('run.log', ', ' + JSON.stringify(e), {'flag':'a+'} )
                  }
                  else statuslog.statuslog(e);
                })
              }
            }

            if(__isElevated){
              return any(elevatedRunasRepos.map((repo)=>performPull(repo))).then(()=>{
                fs.writeFileSync('run.done', 'success')
                return true;
              }).catch(()=>{
                fs.writeFileSync('run.done', 'error')
              })
            }
            else {
              // PB : TODO -- Rename op['runas'] to 'elevate'
              return op['runas']().then(()=>{ return true; })
              .catch(()=>{})
              .finally(()=>{
                if(!processedArgs.runas) {
                  var pendingpulls = [];
                  gitRepos.forEach( (r)=>{ pendingpulls.push(performPull(r)) } )
                  return Promise.all(pendingpulls).then(results =>{
                    return true;
                  }).finally(Traq.finally)
                }
              })
            }
          }
          , 'isInstalled' : ()=>{
            return nodeShellExec('where', [processedArgs._[1]], { inherit : true} ).then(()=>{
              console.log(processedArgs._[1] + ' exists.')
              return true;
            });
          }
          , 'i' : ()=>{
            
            var tasks = []
            tasks.push(op['pull']);
            if(!__isElevated){ 
              tasks.push(op['use'])
              tasks.push(op['npmi'])
            }

            // var tasksdefs = [
            //     ['elxr', ['pull']]
            //   , ['elxr', ['use', 'elixir']]
            //   , ['elxr', ['npmi']]
            // ]
            
            
            // tasksdefs.forEach(tasksdef=>{
            //   tasks.push( ()=> nodeShellExec.apply(null, tasksdef) )
            // })

            return any(tasks);
            
          }
          , 'npmi' : ()=>{
            var tasks = [];
            

            var npmbuildrepos = ['loopback-jsonapi-model-serializer']
            npmbuildrepos.forEach(repo => {
              tasks.push(()=>{ 
                return nodeShellExec('npm', ['i --force'], {
                  inherit : true, shell: true
                  , cwd : repo
                  , env: process.env
                  , title : `npm i for ${repo}`
                }).catch((e)=>{ 
                  console.error('Ignoring Benign Error'); console.error(e);
                }).then(()=>{
                  console.log(`--------------------npm run build for ${repo}--------------------`)
                  return nodeShellExec('npm', ['run build'], {
                    inherit : true, shell: true
                    , cwd : repo
                    , env: process.env
                    , title : `npm run build for ${repo}`
                  }).then(Tasq.then).catch(Tasq.catch)
                }) 
              })
            })
          
            any(tasks).then(()=>{

              gitRepos.push('client/server');
              gitRepos = gitRepos.concat(elevatedRunasRepos);

              var rmtasks = []
              var repotasks = []
              gitRepos.forEach(repo => {

                rmtasks.push(()=>{
                  console.log(`--------------------rm package-lock.json for ${repo}--------------------`)
                  return nodeShellExec('rm', ['package-lock.json'], {
                    inherit : true, shell: true
                    , cwd : repo
                    , env: process.env
                    , title : `rm 'package-lock.json' for ${repo}`
                  }).catch((e)=>{console.error(e)}) 
                })
                
                if( npmbuildrepos.indexOf(repo) < 0) {
                  repotasks.push(
                    ()=>{
                        console.log(`--------------------npm i for ${repo}--------------------`)
                        var p = nodeShellExec('npm', ['i --force'], {
                          inherit : true, shell: true
                          , cwd : repo
                          , env: process.env
                          , title : `npm i for ${repo}`
                        }).then(Tasq.then).catch(Tasq.catch)
                        return p; 
                    }) 
                }
              })

              var bowerRepos = ['client']
              bowerRepos.forEach(repo => {
                repotasks.push(()=>{ 
                  var p = nodeShellExec('bower', ['install'], {
                    inherit : true, shell: true
                    , cwd : repo
                    , env: process.env
                    , title : `bower i for ${repo}`
                  }).then(Tasq.then).catch(Tasq.catch)
                  return p; 
                })
              })

              return Promise.all(rmtasks).then(()=>any(repotasks));
            }).catch(e=>{
              
            }).finally(statuslog.finally)
            
          }
          , 'start' : (label)=>{ 
            console.log('Starting Elixir Server.');
            var env = Object.assign({}, process.env); // Shallow clone it.
            // console.dir(env)
            env.NODE_ENV = process.env.NODE_ENV || 'development';
            env.DEBUG = 'loopback:connector:' + dbForLabel(label)
            var cmd = env.NODE_ENV === 'development' ? 'nodemon' : 'node';
            // cmd = 'node'
            cmd = [cmd, ['--inspect=9228', 'elixir/server.js']] 
            var childPromise = nodeShellExec(...cmd, {
              // inherit : true,
              shell: true, 
              detached: true,
              stdio: 'ignore',
              cwd : 'elixir-server'
              , env: env
            })

            var child = childPromise.process;
            if (typeof child.pid !== 'undefined') {
              console.log(`started Elixir Server PID(${child.pid}) : NODE_ENV=${process.NODE_ENV} ${cmd}`);
              fs.writeFileSync('.elixir-server.elixir.server.pid', child.pid, {
                encoding: 'utf8'
              })
            }

            // nodeShellExec('node', ['--inspect=9226', ' bin/www'], {
            //   inherit : true, 
            //   shell: true, detached: true,
            //   cwd : 'qms/server',
            //   env: env,
            //   shell : true
            // })

            // nodeShellExec('ember', ['s'], {
            //   // inherit : true, 
            //   shell: true, detached: true,
            //   cwd : 'client/',
            //   env: env
            // })
            console.log('Starting Elixir Client Host.');
            var cmd = ['ember', ['s']]
            var childPromise = nodeShellExec(...cmd, {
            // var childPromise = nodeShellExec('node', ['--inspect=9227', './node_modules/.bin/ember', 's'], {
              // PB : TODO -- ember debugging.
              // inherit : true,
              shell: true,
              detached: true,
              stdio: 'ignore',
              cwd : 'client'
              , env: env
            })
            // .catch(e=>console.error(e))

            child = childPromise.process;
            if (typeof child.pid !== 'undefined') {
              console.log(`started Elixir Client Host PID(${child.pid}) : NODE_ENV=${process.NODE_ENV} ${cmd}`);
              fs.writeFileSync('.client.server.pid', child.pid, {
                encoding: 'utf8'
              })
            }

          }
          , 'stop' : (label)=>{ 
            const kill = require('tree-kill');

            var serverPid = fs.readFileSync('.elixir-server.elixir.server.pid', {
              encoding: 'utf8'
            })
            fs.unlinkSync('.elixir-server.elixir.server.pid')
            console.log(serverPid)
            kill(serverPid)      

            serverPid = fs.readFileSync('.client.server.pid', {
              encoding: 'utf8'
            })
            fs.unlinkSync('.client.server.pid')
            console.log(serverPid)
            kill(serverPid)   
          }
          , 'use' : ()=>{
            // use a certain named instance.
            //  Eg : 
              // 1) elxr use elixir
              // 2) elxr use cihsr
            // If environment is not specified defaults to development.
              // 1) NODE=test elxr use elixir

            /*// Steps
            1) Delete Config and Data symlinks
            2) Make Links for config ({{name}}-config-{{node_env}}) and data with the NODE_ENV specified or default to dev 
            3) Iterates all repos and pull all. 'git', ['pull', '--all'].
            4) Iterates all repos and checkout to the ENV specified. 'git', ['checkout', checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV]
            5) Iterates all repos and merge from source configured in mergeSource. 'git', ['merge', mergeSource],
            */
            var runconfig = { NODE_ENV : process.env.NODE_ENV }  
            try { runconfig = Object.assign(runconfig, require('../run.js')) } catch(e) { }
            if((!processedArgs.runas || processedArgs.runas !== 'self') && 
              runconfig.NODE_ENV &&  runconfig.NODE_ENV === (process.env.NODE_ENV || runconfig.NODE_ENV) && 
              processedArgs._[1] && runconfig.use === processedArgs._[1])  {
            
              console.log(`No change detected. Already using requested specs : ${runconfig.NODE_ENV} ${runconfig.use}`)
              if(processedArgs.runas) { fs.writeFileSync('run.done', 'success') }
              return
            }

            var tasks = [
              ()=>{
                if(existsSync('config')) {
                  var p = nodeShellExec('rmdir', ['config'], {inherit : true, shell: true, env: process.env }
                    ).catch((err)=>{ console.log('Ignoring benign error : ' + err); return true; })
                  return p;
                }
                else return Promise.resolve(true);
              },
              ()=>{ 
                if(existsSync('data')) {
                  var p = nodeShellExec('rmdir', ['data'], { inherit : true, shell: true, env: process.env }
                    ).catch((err)=>{ console.log('Ignoring benign error : ' + err); return true; })
                  return p;
                }
                else return Promise.resolve(true);
              },
            ];
            runconfig.NODE_ENV = process.env.NODE_ENV = process.env.NODE_ENV || runconfig.NODE_ENV || 'development';
            if(processedArgs._[1] && runconfig.use !== processedArgs._[1]) runconfig.use = processedArgs._[1];
            if(!runconfig.use) {  throw 'unspecifed use not allowed. Please specify chess instance name.' }
            // console.log(process.env.cwd)
            fs.writeFileSync('./run.js', 'module.exports = ' + JSON.stringify(runconfig))
            
            var checkoutMap = {
              'development' : 'master',
            }

            // cant use git checkout -b it fails with branch already exists.
            var performCheckout = (repo, branch)=>{
              if(!branch) return Promise.resolve({ 'skipped' : true })
              if(excludeCheckouts[repo]) return Promise.resolve({ 'skipped' : true })
              return nodeShellExec('git', ['checkout', branch || checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV], {
                // return nodeShellExec('git', ['switch', '-m', '-C', checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV], {
                // inherit : true, shell: true, 
                cwd : repo
                // , stdio : ignore // Use when we want to silcence output completely.
                , runas : processedArgs.runas
                , title : `git checkout ${branch ||checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV} for ${repo}`
              }).catch((e)=>{ console.error(e); return { error : true, message : repo} }) 
            }
            if(runconfig.NODE_ENV === 'development')  performCheckout = ()=>{ return Promise.resolve(true) }

            var performPullAll = (repo)=>{
              if(excludeCheckouts[repo]) return Promise.resolve({ 'skipped' : true })
              return nodeShellExec('git', ['pull', '--all'], {
                // inherit : true, shell: true, 
                cwd : repo
                , runas : processedArgs.runas
                , title : `git pull -all for ${checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV} ${repo}`
              }).catch((e)=>{ console.error(e); return { error : true, message : repo} }) 
            }

            var mergeSources = {
              'development' : null,
              'test' : 'master',
              'production' : 'master'
            }
            var excludeCheckouts = Object.assign(exludeMergeRepos)
            delete excludeCheckouts[`elixir-config-${runconfig.NODE_ENV}`]
            delete excludeCheckouts[`cihsr-config-${runconfig.NODE_ENV}`]

            var mergeSource = mergeSources[checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV]
            var performMerge = (repo)=>{
              if(exludeMergeRepos[repo]) return Promise.resolve({ 'skipped' : true })
              return nodeShellExec('git', ['merge', mergeSource], {
                inherit : true, shell: true, 
                cwd : repo
                , runas : processedArgs.runas
              }).catch((e)=>{ console.error(e) }) 
            }
            if(runconfig.NODE_ENV === 'development')  performMerge = ()=>{ return Promise.resolve(true) }

            any(tasks).then(()=>{
              if(!processedArgs.runas) return op['runas']() 

              tasks = [
                ()=>{ 
                  // Use junctions to avoid npm package issues
                  var p = nodeShellExec('mklink', ['/J', 'config', runconfig.use + '-config' + '-' + process.env.NODE_ENV ], {
                    inherit : true, shell: true
                    , env: process.env
                  }).catch((e)=>{ console.error(e) }) 
                  return p;
                }
              ];
              if(processedArgs._[1]) {   
                tasks = tasks.concat(
                  [
                    ()=>{ 
                      var p = nodeShellExec('mklink', ['/J', 'data', runconfig.use + '-data'], {
                        inherit : true, shell: true
                        , env: process.env
                      }).catch((e)=>{ console.error(e) }) 
                      return p;
                    }
                  ]
                ) 
              }

              return any(tasks)
                //target is the env is we specify in elxr use command. Default is dev
                .then( //Switch to target branch
                  () => any([ any(gitRepos.map((repo)=>performCheckout(repo, process.env.NODE_ENV || 'development')))
                            , any(elevatedRunasRepos.map((repo)=>performCheckout(repo, process.env.NODE_ENV || 'development')))]) )
                .then( //PULL from target branch
                  () => any([ any(gitRepos.map((repo)=>performPullAll(repo))), any(elevatedRunasRepos.map((repo)=>performPullAll(repo)))]) )
                .then( //Switch to merge source branch
                  () => any([ any(gitRepos.map((repo)=>performCheckout(repo, mergeSources[process.env.NODE_ENV || 'development'] )))
                            , any(elevatedRunasRepos.map((repo)=>performCheckout(repo, mergeSources[process.env.NODE_ENV || 'development'])))]) )  
                .then( //Pull on merge source branch
                  () => any([ any(gitRepos.map((repo)=>performPullAll(repo))), any(elevatedRunasRepos.map((repo)=>performPullAll(repo)))]) )
                .then( //Switch to target branch
                  () => any([ any(gitRepos.map((repo)=>performCheckout(repo, process.env.NODE_ENV || 'development')))
                            , any(elevatedRunasRepos.map((repo)=>performCheckout(repo, process.env.NODE_ENV || 'development')))]) )
                .then( //Merge source branch to target branch
                  () => any([ any(gitRepos.map((repo)=>performMerge(repo))).catch(err=>{ console.error('error in performMerge ' + err)}) ,
                              any(elevatedRunasRepos.map((repo)=>performMerge(repo))).catch(err=>{ console.error('error in performMerge ' + err)})]) )
                .then( () => {
                  // Move test config from dev.
                  // if(process.env.NODE_ENV === 'test'){
                  //   var devcfgreponame =  runconfig.use + '-config' + '-development'; 
                  //   var testcfgreponame =  runconfig.use + '-config' + '-test';
        
                  //   var testcfgdir = path.dirname(__dirname) + '/' +  testcfgreponame + '/'
                  //   var devcfgdir = path.dirname(__dirname) + '/' +  devcfgreponame + '/' //eg (elxr/../elixir-config.development)
                    
                  //   return any([
                  //       ()=>{ 
                  //         return nodeShellExec('git', ['checkout', 'test'], {
                  //           inherit : true, shell: true, 
                  //           cwd : testcfgdir
                  //           // , env: process.env
                  //           , runas : processedArgs.runas
                  //           , title : `git checkout test for ${testcfgreponame}`
                  //         }).catch((e)=>{ console.error(e) })
                  //       }
                  //     , ()=> {
                  //         return nodeShellExec('git', ['checkout', 'master'], {
                  //           inherit : true, shell: true, 
                  //           cwd : devcfgdir
                  //           // , env: process.env
                  //           , runas : processedArgs.runas
                  //           , title : `git checkout master for ${devcfgreponame}`
                  //         }).catch((e)=>{ console.error(e) })
                  //       }
                  //     , ()=> {
                  //         globSync( '**/*.test.js', {cwd : devcfgdir}).map((filename) => {    
                  //           console.log('File found : ' + devcfgdir + filename)       
                  //           fs.copyFileSync(devcfgdir + filename, testcfgdir+ filename);
                  //         })
                  //         return nodeShellExec('git', ['checkout', 'test'], {
                  //           inherit : true, shell: true, 
                  //           cwd : devcfgdir
                  //           // , env: process.env
                  //           , runas : processedArgs.runas
                  //           , title : `git checkout test for ${devcfgreponame}`
                  //         }).catch((e)=>{ console.error(e) })
                  //       }
                  //   ])
                  // } 
                  // else {
                    return Promise.resolve(true)
                  // }
                })
              .then(()=>{
                fs.writeFileSync('run.done', 'success')
              }).catch(()=>{
                fs.writeFileSync('run.done', 'error')
              })
            }).catch(()=>{
              fs.writeFileSync('run.done', 'error')
            })

            // Antibiotic stewardship program.
            // 1st use is fine.
            // Max vials dispense
            // 2nd use Pharmacy needs justification Form.
            // Approval after a certain period of time.
          }
          , 'g' : ()=>{
            if(processedArgs.h) { 

              console.log('elxr g [modelname] => generate a model named [modelname]'); 
              console.log('elxr g => regenerate all known models'); 
              return 
            }
            // var child = nodeShellExec('mkdir', ['-p', label], { inherit : true} );
            // console.log('Starting directory: ' + process.cwd());
            // try {
            //     child = child.on('close', () => { process.chdir(label) } );
            //     console.log('New directory: ' + process.cwd()); 
            // }
            // catch (err) {
            //     console.log('chdir: ' + err);
            // }
            // child.on('close', function(){
                // var options = {
                //       shell : true 
                //     , inherit : true
                //     // , cwd : '' + process.cwd
                //     // , env : process.env
                // };
                // nodeShellExec('git', ['init'], { inherit : true});
              if(0){
                // PB : TODO -- Special google chrome profile for tests etc.
                nodeShellExec('pwd', { inherit : true});
                // /c/Program\ Files\ \(x86\)/Google/Chrome/Application/chrome.exe --user-data-dir=/c/chess/instances/elixir_01/data/Google/Chrome/User\ Data --profile-directory="chess"
                // "C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" --user-data-dir="C:\chess\instances\elixir_01\data\Google\Chrome\User Data" --profile-directory="chess" http://localhost:4200/admin/crud/create/item
                // "C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" --user-data-dir="C:\chess\instances\elixir_01\data\Google\Chrome\User Data" --profile-directory="chess" http://localhost:4200/tests/index.html?grep=loopback
                nodeShellExec("C:/Program Files (x86)/Google/Chrome/Application/chrome.exe", [
                    "--profile-directory=Profile 1"
                  , 'http://localhost:4200/tests/index.html?grep=model convert ember to loopback' + '&filter=none' /*+ '&filter=model convert ember to loopback'*/]);
                
              }
                // nodeShellExec('npm', ['init', '-y'], options);
                // nodeShellExec('npm', ['init', '-y'], options);
            // })

            var g = {
              'client' : ()=>{
                console.info('Creating new ember client named : ' + processedArgs._[2] ) ;
                var step1 = nodeShellExec('cmd', ['/c', 'ember', 'new', processedArgs._[2]], {
                  stdio: ['pipe', process.stdout, process.stderr],
                  inherit : true,
                  shell: true,
                  cwd : path.dirname(__dirname),
                  env: env
                })
              },

              'modelr' : ()=>{
                var tasks = [
                  ()=>{
                    var p = nodeShellExec('"ember"', [
                      'g'
                      , 'modelr'
                      , processedArgs._[2]], {
                      inherit : true, shell: true, env: process.env
                    }).then(()=>{
                      console.log('Blueprint generation complete for : ' + processedArgs._[2])
                      return true;
                    }).catch((e)=>{ console.error(e) }) 
                    return p;
                  },
                  ()=>{ 
                    var chromePrefsFile = "C:\\chess\\instances\\elixir_01\\data\\Google\\Chrome\\User Data\\chess\\Preferences";
                    var chromeprefs = fs.readFileSync(chromePrefsFile, { encoding: 'utf8' })
                    chromeprefs = JSON.parse(chromeprefs)
                    var previous = chromeprefs.download.default_directory;
                    var parentDir = path.dirname(__dirname);
                    chromeprefs.download.default_directory = parentDir + "\\client\\app\\templates\\components\\resource";
                    fs.writeFileSync(chromePrefsFile, JSON.stringify(chromeprefs))
                    // PB : TODO -- detect where chrome is installed.
                    // PB : TODO -- set the download dir to the place where files are needed.
                    var p = nodeShellExec('"C:/Program Files (x86)/Google/Chrome/Application/chrome.exe"', [
                      '--user-data-dir="C:\\chess\\instances\\elixir_01\\data\\Google\\Chrome\\User Data"'
                      , '--profile-directory="chess"'
                      , 'http://localhost:4200/admin/crud/create/' + processedArgs._[2]], {
                      inherit : true, shell: true
                          , env: process.env
                    }).then(()=>{
                      chromeprefs.download.default_directory = previous;
                      fs.writeFileSync(chromePrefsFile, JSON.stringify(chromeprefs))
                      return true;
                    }).catch((e)=>{ console.error(e) }) 
                    return p;
                  }
                  ,
                  ()=>{
                    console.log('Browser process should have closed here....')
                    return true;
                  }
                ]
                any(tasks)
                
              }

            }

            g[processedArgs._[1]]();
          }
        }
        return op[label] ? op[label]() : null;
      } 

      // mysqldump --add-drop-table --no-data -u root -p db_name | grep 'DROP TABLE' ) > drop_all_tables.sql
      // mysql -u root -p db_name < drop_all_tables.sql

      var mysql = '../xampp/mysql/bin/mysql'
      var mysqldump = '../xampp/mysql/bin/mysqldump'

      // --runas
      if(processedArgs.runas) {
        // Weve been asked to run in priviledged mode. Check if we already are privileged.
        __runcmd('runas')
      }
      else __runcmd(processedArgs.label || processedArgs._[0] || 'h');

    })



  })

}
catch(e){
  fs.writeFileSync('run.log', ', ' + JSON.stringify({ error : e.message }), {'flag':'a+'} )
  fs.writeFileSync('run.done', 'error');
}