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)
var cli = require('./cliverse')
var nodeShellExec = cli.nodeShellExec;
var chalk = require('chalk')


const BUILD_VERSION = '[VI]Version: {version} - built on {date}[/VI]';
const runtimestamp = (new Date()).getTime();
function getVersion() { return BUILD_VERSION; }
console.log(getVersion())

// 'use strict';

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

// 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 cliargs = utils.cliargs;
const processedArgs = cliargs(process.argv.slice(2));
console.dir(processedArgs)
var globSync = require('glob').sync;

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

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

// Directory shallow walk and do perform on each dir.
const dirs = async (perform, path) => {
  for (const dir of await readdir(path || process.cwd(), { withFileTypes: true })) {
    if (dir.isDirectory()) perform(dir)
  }
}

var getShellTask = (command, args, options) => {
  options = options || {}
  return () => {
    var p = nodeShellExec.apply(null, [command, args, Object.assign({
      inherit: true, shell: true, env: ENV, title: `${command} ${args}`
    }, options)
    ])
    if (options.ignorefailures) {
      return p.catch(e => {
        // Ignore. Not a major error.
      })
    }
    else return p;
  }
}

var callsheltask = (args) => { return () => { return nodeShellExec.apply(null, args) } }

var getTaskCheckExists = (command, options) => {
  options = options || {}
  return () => {
    var p = nodeShellExec.apply(null, ['where', [command]])
    if (options.ignorefailures) {
      return p.then(() => { return true }).catch(e => { // Ignore. Not a major error.
        return false;
      })
    }
    else return p.then(() => { return true });
  }
}

var getTaskWithElevation = function(tasdef){
  return ()=>{
    if (__isElevated) { 
      return tasdef.elevatedpulltasks();
    }
    else {
      // PB : TODO -- Rename op['runas'] to 'elevate'
      return op['runas']().then(() => { return true; })
        .catch((e) => {
          console.error(e)
        })
        .finally(() => {
          if (!processedArgs.runas) {  return tasdef.regularpulltasks(); }
        })
    }
  }
}

var getTaskWithoutElevation = function(tasdef){
  return ()=>{
    if(!processedArgs.runas) {  return tasdef.regularpulltasks(); }
    else Promise.resolve(true)
  }
}

var gitops = {

  getdiscoverbranchcmd : function(repo){

    var parameters = ['-c', 'branch=`git rev-parse --abbrev-ref HEAD`;for i in `git remote`; do git pull $i $branch; done;']
    var cmd = [gitbash
      , ['-c', 'branch=`git rev-parse --abbrev-ref HEAD`;for i in `git remote`; do git pull $i $branch; done;']
      , { cwd: instanceroot + '/' + repo, title: 'pull all origins for ' + repo + ' ' + parameters.join(' ') }]
    return cmd
  }
}

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

  if(branch) {
    var parameters = ['-c', 'for i in `git remote`; do git pull $i ' + branch + '; done;']
    var pullCmd = [ gitbash
      , ['-c', 'for i in `git remote`; do git pull $i ' + branch + '; done;']
      , { cwd: instanceroot + '/' + repo, title : 'pull all origins for ' + branch + '  ' + repo + ' ' + parameters.join(' ') }]
  }
  else {
    console.warn('No branch was specified detecting from working client.')
    var pullCmd = gitops.getdiscoverbranchcmd(repo)
  }
  // var pullCmd = ['pullall', [], { cwd : repo }]
  if (useGitPull) pullCmd = ['git', ['pull'], {
    inherit: true, shell: true,
    cwd: instanceroot + '/' + repo
    // , env: process.env
    , runas: processedArgs.runas
    , title: `git pull ${repo}`
  }]
  return pullCmd
}

var performPull = (repo, branch) => {
  // PB : TODO -- Handle no branch passed in case.
  // if(!branch) { throw 'No branch specified' }

  if (existsSync(instanceroot + '/' + repo)) {
    var branchprint =  branch ? ' branch :' + branch  : '';
    console.log('pulling ' + instanceroot + '/' + repo + branchprint )
    return nodeShellExec.apply(null, getPullCmd(repo, branch)).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 {
    console.log('cloning ' + repo)
    // PB : TODO -- detect if a clonable repo exists in currentGitAuthUser
    return nodeShellExec('git', ['clone', '-c', 'core.symlinks=true', selectedinstance.reposerver + `/${defaultRepoOwner}/` + repo + '.git'],
      {
        inherit: true, shell: true,
          env: process.env
        , cwd : instanceroot 
        , 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: instanceroot + '/' + repo
            , runas: processedArgs.runas
            , title: `git core.symlinks --replace-all true for ${selectedinstance.reposerver + `/${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);
      })
  }
}

// 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 acquireElevationState = () => {
  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);
}


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

// 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'
}

// SAM : TODO Use nodeshellexec where to detect git installation dir
var gitbash = "C:\\Program Files\\Git\\bin\\sh.exe"
// var gitbash = "G:\\Installed\\Git\\bin\\sh.exe"
// Relevant git repos
// var repomanifest = require('../'+repomanifest.instanceName+'-config-'+ nodeenv +'/repo-manifest')()
var exludeMergeRepos = [];
var useGitPull = processedArgs.useGitPull || false;
var configPromise = null

// elxr cli operations
var op = {
  'h': () => { console.log(elxr.help()); return '-h' }
  , 'clean' : () => {
    // delete all node_module folders and links.
    var tasklist = [];
    dirs( (repodir)=> tasklist.push(getShellTask('rm',['-rf', 'node_modules'], { cwd : instanceroot + '/' + repodir.name })()), instanceroot )
    return Promise.all(tasklist)
  }
  , '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 => {
        var namedArgs = [];
        console.log('result : ' + JSON.stringify(r))
        Object.keys(processedArgs).forEach((v) => { v != '_' ? namedArgs.push('--' + v + '=' + processedArgs[v]) : null; })
        // PB : TODO -- Convert all the cli args back to string.
        var args = [`${selectedinstance.root}/.elxr/run-${runtimestamp}/windowselevate.hta`].concat(processedArgs._).concat(namedArgs.join(' ')); args.push('--runas=self');
        args.push('--nodepath=' + r[r.length - 1])
        if (!processedArgs.node_env) args.push('--node_env=' + ENV.NODE_ENV)
        if (processedArgs.debug) 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:', selectedinstance.reposerver.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: `${instanceroot + '/' + 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', `${selectedinstance.reposerver}/${repo}.git`], { cwd: `${instanceroot + '/' + 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:', selectedinstance.reposerver.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: `${instanceroot + '/' + 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' })
  }
  // git remote equivalents...
  // git branch --set-upstream-to=elixir-unc/master master
  // git push --set-upstream elixir-unc branch..
  , '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: instanceroot + '/' + repo }
      // console.log(repo)
      if (pushable) {
        return [
          ['git', ['remote', 'set-url', remotename, url + '/' + repo], { cwd: instanceroot + '/' + repo }]
        ]
      }
      else {
        console.error('not supported for non-pushable')
      }

    }

    var perform_git_seturl = (dir) => {
      op['is-git-repo'](dir).then((logEntry) => {
        any(serial_perform_git_seturl(dir.name).map(x))
      }).catch((e) => {
        // console.log('Failed : ' + dir.name)
      })
    }

    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: instanceroot + '/' + repo }
      // console.log(repo)
      if (pushable) {
        return [
          ['git', ['remote', 'add', remotename, url + '/' + repo], { cwd: instanceroot + '/' + repo }]
          , ['git', ['pull', remotename, branch], { cwd: instanceroot + '/' + repo }]
          , ['git', ['branch', `--set-upstream-to=${remotename}/${branch}`, branch], { cwd: instanceroot + '/' + repo }]
        ]
      }
      else {

        return [
          ['git', ['remote', 'add', remotename, url + '/' + repo], { cwd: instanceroot + '/' + repo }]
          , ['git', ['remote', `set-url`, '--push', remotename, 'no-pushing'], { cwd: instanceroot + '/' + repo }]
          , ['git', ['pull', remotename, branch], { cwd: instanceroot + '/' + repo }]
          , ['git', ['branch', `--set-upstream-to=${remotename}/${branch}`, branch], { cwd: instanceroot + '/' + 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((logEntry) => {
        // console.log(code)
        if (logEntry.success) {
          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

    dirs(perform_git_add)
  }
  , 'remove': (remotename) => {
    remotename = remotename || processedArgs._[1]
    var serial_perform_git_remove = (repo) => {
      var options = { cwd: instanceroot + '/' + repo }
      // console.log(repo)
      return [
        ['git', ['remote', 'remove', remotename], { cwd: instanceroot + '/' + 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((logEntry) => {
        // console.log(code)
        if (logEntry.success) {
          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

    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: instanceroot + '/' + repo }
      // console.log(repo)
      return [
        ['git', ['remote', 'add', 'chess', `${selectedinstance.reposerver}/${user}/${repo}.git`], { cwd: instanceroot + '/' + repo }]
        , ['git', ['remote', 'set-url', '--push', 'chess', 'no-pushing'], { cwd: instanceroot + '/' + repo }]
        , ['git', ['remote', 'set-url', 'origin', `${selectedinstance.reposerver}/${user}/${repo}.git`], { cwd: instanceroot + '/' + 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((logEntry) => {
        // console.log(code)
        if (logEntry.success) {
          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

    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.map((def) => performPull(def.repo, def.branch || 'master'))
    if (__isElevated) {
      return any(elevatedRunasRepos.map((def) => performPull(def.repo, def.branch || 'master'))).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

    return elxr.getpulltask()()
  }
  , 'isInstalled': () => {
    return nodeShellExec('where', [processedArgs._[1]], { inherit: true }).then(() => {
      console.log(processedArgs._[1] + ' exists.')
      return true;
    });
  }
  , 'i' : () => {

    var tasks = []
    // tasks.push(op['pull']);
    tasks.push(getShellTask.apply(null, ['rm', [instanceroot + '/run.js'], { ignorefailures: true }]))
    tasks.push(op['use'])
    if (!__isElevated) {
      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 = [];

    // Build fails without babel...
    tasks.push(getShellTask(
      'npm',[ 'i', '-g', 'babel-cli' ]
    ) )

    var npmbuildrepos = ['loopback-jsonapi-model-serializer']
    npmbuildrepos = []
    npmbuildrepos.forEach(repo => {
      tasks.push(() => {
        return nodeShellExec('npm', ['i --force'], {
          inherit: true, shell: true
          , cwd: instanceroot + '/' + 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: instanceroot + '/' + 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);

      // gitRepos = [
      //   // 'bbhverse', 'serververse', 'elixir-server', 
      //   // 'clientverse', 
      //   'client'
      // ];
      var rmtasks = []
      var repotasks = []
      var env = Object.assign({}, process.env)
      delete env.NODE_ENV
      gitRepos.forEach(repodef => {

        rmtasks.push(
          // () => {
            // console.log(`--rm package-lock.json for ${repodef.repo}--------------------`)
            // return nodeShellExec(`"${gitbash}"`, ['-c', '"rm  package-lock.json"'], {
            nodeShellExec('rm', ['package-lock.json'], {
              inherit: true, shell: true
              , cwd: instanceroot + '/' + repodef.repo
              , env: process.env
              , title: `rm 'package-lock.json' for ${repodef.repo}`
            })
            .then(()=>{
              console.log(`--rm package-lock.json for ${repodef.repo}--------------------`)
            }).catch((e) => { console.error(e) })
          // }
        )

        if (npmbuildrepos.indexOf(repodef.repo) < 0) {
          repotasks.push(
            () => {
              console.log(`--npm i for ${repodef.repo}--------------------`)
              var p = nodeShellExec('npm', ['i', '--force'], {
                inherit: true, shell: true
                , cwd: instanceroot + '/' + repodef.repo
                , env
                , title: `npm i for ${repodef.repo}`
              }).then(Tasq.then).catch(Tasq.catch)  
              return p;
            })
        }
      })


      // PB : NOTE -- npm i for client does not complete when NODE_ENV=production 
      // therefore bower doesn't get installed !!! which then fails installing the bower dependenciew !!!
      // We work around this by running npm i for client without any NODE_ENV which probably defualts to development.
      // PB : TODO -- Investigate why NODE_ENF has an impact on npm i !??
      // Second time try also doesnt work.
      // repotasks.push(
      //   () => {
      //     var env = Object.assign({}, process.env)
      //     delete env.NODE_ENV
      //     console.log(`--------------------second time npm i for client--------------------`)
      //     return nodeShellExec(`"${gitbash}"`, ['-c', '"npm i --force"'], {
      //     // return nodeShellExec('npm', ['i --force'], {
      //       inherit: true, shell: true
      //       , cwd: instanceroot + '/' + 'client'
      //       , env
      //       , title: `npm i for client`
      //     }).then(Tasq.then).catch(Tasq.catch)
      //   })

      var bowerRepos = [{ repo : 'client'}]
      bowerRepos.forEach(repodef => {
        repotasks.push(() => {
          console.log(instanceroot + '/' + repodef.repo + '/node_modules/bower/bin/bower')
          // var p = nodeShellExec('node_modules/bower/bin/bower', ['install'], {
          var p = nodeShellExec(`"${gitbash}"`, ['-c', '"node_modules/bower/bin/bower i"'], {

            inherit: true, shell: true
            , cwd: instanceroot + '/' + repodef.repo
            , env: process.env
            , title: `bower i for ${repodef.repo}`
          }).then(Tasq.then).catch(Tasq.catch)
          return p;
        })
      })
      // console.log('rmtasks.length : ' + rmtasks.length)
      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: instanceroot + '/' + '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: instanceroot + '/' + '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)
  }
  , 'model' : () => {
    if (__isElevated) { 
      var tasks = [
        () => {
          var p = nodeShellExec('mklink', [ `${processedArgs._[2]}.json`
              , `..\\..\\node_modules\\chess-server-lib\\common\\models\\${processedArgs._[2]}.json`], {
            inherit: true, shell: true
            , cwd : instanceroot + `/${selectedinstance.instanceName}-server/${selectedinstance.instanceName}/models`
            , title: `mklink  ${processedArgs._[2]}.json ..\\..\\node_modules\\chess-server-lib\\common\\models\\${processedArgs._[2]}.json`
            , env: process.env
          }).catch((e) => { console.error(e) })
          return p;
        }
      ];
      return any(tasks).then(() => {
        fs.writeFileSync('run.done', 'success')
      }).catch(() => {
        fs.writeFileSync('run.done', 'error')
      })
    }
    else return op['runas']()
  }
  , '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: repomanifest.node_env }
    try { runconfig = Object.assign(runconfig, require(instanceroot + '/run.js')) } catch (e) { }
    // We no longer need to check ruans.. ??? if we were initiated from self invoked privileged shell ?
    if (( /*processedArgs.runas && processedArgs.runas !== 'self' &&*/ !processedArgs.force) &&
      runconfig.NODE_ENV && runconfig.NODE_ENV === (repomanifest.node_env || runconfig.NODE_ENV) &&
      repomanifest.instanceName && runconfig.use === repomanifest.instanceName) {

      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(instanceroot + '/run.js', 'module.exports = ' + JSON.stringify(runconfig))

    // Maps an environment to a branch. Not required if the branch is appropriately named.
    var checkoutMap = { 'development': 'master' }

    var branch = checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV
    
    var performPullOrCloneForBranch = (def)=>{
      var promise = Promise.resolve(true)
      if (!branch) {
        var dscoverbranchcmd = gitops.getdiscoverbranchcmd(repo)
        
        promise = nodeShellExec.apply(null, dscoverbranchcmd(repo)).then(__branch=>{ branch = __branch})
          .catch((e) => { console.error(e); return { error: true, message: repo } })
  
      }
        
      return promise = promise.then(()=>{ return elxr.getpulltask(def)() }).catch(e => { console.error( 'performPullOrCloneForBranch : Failed ' + e )})
    }

    var performCloneAndCheckout = null;
    // cant use git checkout -b it fails when branch already exists.
    var performCheckout = performCloneAndCheckout = (def) => {
      if (excludeCheckouts[def.repo]) return Promise.resolve({ 'skipped': true })
      
      return performPullOrCloneForBranch(def).then(()=>{
        nodeShellExec('git', ['checkout', def.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: instanceroot + '/' + def.repo
          // , stdio : ignore // Use when we want to silence output completely.
          , runas: processedArgs.runas
          , title: `git checkout ${def.branch || checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV} for ${def.repo}`
        }).then(()=>{ console.log( `SUCCESS : git checkout ${def.branch || checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV} for ${def.repo}` ) }).catch((e) => { console.error(e); return { error: true, message: def.repo } })
      })
    }

    // var enqueueCheckout = function(def){ enqueue(elevatedqueue, performCheckout, def) }
    // var enqueueMerge = function(def){ enqueue(elevatedqueue, performMerge, def) }

    var elevatedqueue = [];
    var enqueueOnce = (queue, task, def) => {
      var found = queue.find(element => { 
        var keys = Object.keys( element ) 
        for(var k=0; k < keys.length; k++) { 
          if(element[keys[k]] !== def[k]) return false;
        } 
      })
      queue.push(function(){ return task(this)}.bind(def));
    }
    var enqueue = (queue, task, def) => {
      queue.push(function(){ return task(def)}.bind(def));
    }

    var mergeSources = {
      'development': null,
      'test': 'master',
      'production': 'master'
    }
    var mergesource = mergeSources[checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV]

    // Checkout is reduced to pull provided the current branch is the targetbranch 
    if(branch === mergesource) performCheckout = (def) => {   
      var dscoverbranchcmd = gitops.getdiscoverbranchcmd(repo)
      return nodeShellExec.apply(null, dscoverbranchcmd(repo)).then(__branch=>{ 
        
        if(branch === __branch) return performCloneAndCheckout(def)
        return performPullOrCloneForBranch(def) 
      })
      .catch((e) => { console.error(e); return { error: true, message: repo } })
    }
    // else performCheckout = (def) => { return performPullOrCloneForBranch(def) }

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

    var performMerge = (def) => {
      if (exludeMergeRepos[def.repo]) return Promise.resolve({ 'skipped': true })
      return nodeShellExec('git', ['merge', mergesource], {
        inherit: true, shell: true,
        cwd: instanceroot + '/' + def.repo
        , runas: processedArgs.runas
      }).catch((e) => { console.error(e) })
    }
    if(!mergesource || branch === mergesource) performMerge = () => { return Promise.resolve(true) }

    // var performRepoOperation = function(def) {
    //   elevatedRunasRepos.map((repo) => enqueueCheckout({ repo, branch: def.branch, requiresElevation : true }))
    //   return any(gitRepos.map((repo) => performCheckout({ repo, branch: def.branch})))
    // }

    return any(tasks).then(() => {
      var pr = Promise.resolve(true)
      if (!__isElevated)  {
        pr = op['runas']()
        return pr.then(()=>{

          //target is the env is we specify in elxr use command. Default is dev
            //Switch to target branch
          return any(gitRepos.map((repodef) => { return performCheckout({ repo : repodef.repo, branch}).catch(e=>{ console.log(e); }) }   ))
          // pull or clone target branch
          .then(() => {
            if(!mergesource || branch === mergesource) return Promise.resolve(true)
            return any(gitRepos.map((repo) => performPullAll(repo))) 
          })
          // switch to source branch
          .then( () => {
              if(!mergesource || branch === mergesource ) return Promise.resolve(true)  // Dont do anything if there is no source to merge from.
              return any(gitRepos.map((repodef) => performCheckout({ repo : repodef.repo, branch: mergesource}))) 
          })
          //Pull on merge source branch
          .then( () => {
              if(!mergesource || branch === mergesource ) return Promise.resolve(true)
              return any(gitRepos.map((repo) => performPullAll(repo)))
            })
          //Switch to target branch
          .then( () => { 
            if(!mergesource || branch === mergesource ) return Promise.resolve(true)
            return any(elevatedRunasRepos.map((repodef) => performCheckout({ repo : repodef.repo, branch}))) 
          })
          .then( //Merge source branch to target branch
            () => {
              if(!mergesource || branch === mergesource) return Promise.resolve(true)
              return any(gitRepos.map((repo) => performMerge( repo ))).catch(err => { console.error('error in performMerge ' + err) })
            })
        })
      }
      else {
        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
              , cwd : instanceroot
              , 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
                  , cwd : instanceroot
                  , env: process.env
                }).catch((e) => { console.error(e) })
                return p;
              }
            ]
          )
        }
  
        return any(tasks).then(()=>{
              // checkout target branch
          return any(elevatedRunasRepos.map((repodef) => performCheckout({ repo : repodef.repo, branch, requiresElevation : true}))) 
            // pull or clone target branch
            .then(() => {
              if(!mergesource || branch === mergesource) return Promise.resolve(true)
              return any(elevatedRunasRepos.map((repo) => performPullAll(repo))) 
            })
            // switch to source branch
            .then( () => {
              if(!mergesource || branch === mergesource) return Promise.resolve(true)
              return any(elevatedRunasRepos.map((repodef) => performCheckout({ repo : repodef.repo, branch: mergesource, requiresElevation : true}))) 
            })
            //Pull on merge source branch
            .then( () => {
              if(!mergesource || branch === mergesource) return Promise.resolve(true)
                return any(elevatedRunasRepos.map((repodef) => performPullAll({repo : repodef.repo, requiresElevation : true })))
              })
            //Switch to target branch
            .then( () => { 
              if(!mergesource || branch === mergesource) return Promise.resolve(true)
              return any(elevatedRunasRepos.map((repodef) => performCheckout({ repo : repodef.repo, branch, requiresElevation : true}))) 
            })
            .then( //Merge source branch to target branch
              () => {
                if(!mergesource || branch === mergesource) return Promise.resolve(true)
                return any(elevatedRunasRepos.map((repodef) => performMerge({ repo : repodef.repo, requiresElevation : true }))).catch(err => { console.error('error in performMerge ' + err) })
            })
            .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]]();
  }
}

var util = require('util')
var cliname = 'elxr';
var ver = '1.1';
var help = `# list of commands... please refer dveloper documentation for ${cliname}
  ${
  // util.inspect(
  [Object.keys(op)]
  // )
  }
`;

var elxr = {
  help() {
    return chalk.cyanBright(`
-------------------------------------------------------------------------------
  *** BBH Elixir ***  
-------------------------------------------------------------------------------
  elxr ${ver}
    A cli tool for chess
    ${help}
-------------------------------------------------------------------------------
  `)
  }
  , info() {
    return chalk.cyanBright(`
-------------------------------------------------------------------------------
  *** BBH Elixir ***  
-------------------------------------------------------------------------------
  elxr ${ver}
    A cli tool for chess
-------------------------------------------------------------------------------
  `)
  }
  , getpulltask(def){

    def = def || {
      requiresElevation : true,
      reqularRepos : gitRepos,
      elevatedRepos : elevatedRunasRepos
    }
    console.log(`-------------------Processing pull for : ${def.repo} ${def.branch}`)
    console.dir(def)

    var env = Object.assign({}, process.env); // Shallow clone it.
    console.log('Running exlr pull : ' + path.dirname(__dirname))

    var useGitPull = processedArgs.useGitPull || false;

    if(def.elevatedRepos || def.reqularRepos) {
      if(def.elevatedRepos) def.requiresElevation = true;
      else delete def.requiresElevation;
    }
    else {
      if(def.requiresElevation) def.elevatedRepos = [def] 
      else def.reqularRepos = [def] 
    }

    var elevatedpulltasks = null;
    var regularpulltasks = function(){ return Promise.resolve(true) }
    if(def.elevatedRepos){
      elevatedpulltasks = function() {
        return any(def.elevatedRepos.map((def) => performPull(def.repo))).then(() => {
          // fs.writeFileSync('run.done', 'success')
          return true;
        }).catch((e) => {
          console.error(e) 
          fs.writeFileSync('run.done', 'error') 
        })
      }
    }
    if(def.reqularRepos) {
      var regularpulltasks = function(){
        var pendingpulls = [];
        def.reqularRepos.forEach((def) => { pendingpulls.push(performPull(def.repo)) })
        return Promise.all(pendingpulls).finally(Traq.finally)
      }
    }
    if(elevatedpulltasks) return getTaskWithElevation( { elevatedpulltasks, regularpulltasks} )
    else return getTaskWithoutElevation({ regularpulltasks})
  }
}

// The main elxr cli process
function elxrworker() {
  // Everything runs after this check is completed. Elevation occurs out of process when needed.
  gitRepos = repomanifest.repos
  // gitRepos = ['chess-server-lib'];

  // Repositiories that have symlinks that require elevated priviletes in windows to create symlinks
  elevatedRunasRepos = repomanifest.elevated
  // Repos that should excluded from merge for releases...
  exludeMergeRepos = repomanifest.exludeMergeRepos

  var env = Object.assign({}, process.env); // Shallow clone it.
  var __runcmd = function (label) {
    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.
    return __runcmd('runas')
  }
  else return __runcmd(processedArgs.label || processedArgs._[0] || 'h');
}

var getManifest = function () {
  // Once choices are made we need to load config according to those choices.

  // No trace of a previous run...
  // Default Config...
  return repomanifest = selectedinstance;
}

function acquireChoices(selectedinstance) {

  var hasconfig = false;
  console.warn(chalk.yellow(`
-------------------------------------------------------------------------------
Warning : Cannot locate your preferred configuration since it was not specified
You should fork the default chess configuration to customize and make it 
your own instance with a named config as 
  {{yourowninstancename}}-config-{{yourcurrentenvironment}} 
And then run this tool as follows
  NODE_ENV={{yourenvironment}} elxr i {{yourowninstancename}} 
OR
Run this tool with the following command to use a quick start default.
node elxr --default
OR
Choose the the option to create a new instance for you interactively.

We will run your choice of default or create your own at the next prompt.
-------------------------------------------------------------------------------
  `))
  var prompt = cli.prompter;
  return prompt.ask(`Choose an option :
      d) Install the default chess instance. 
          => elxr i chess node_env=development --default
      n) Create your custom new instance interactively
          => elxr i {{instanceName}} node_env={{environment}}
      i) Choose an instance and environment to install
          => elxr i {{instanceName}} node_env={{environment}}
      c) Choose a command to run ( pull, use, i, npmi ... ) <= pull
          => elxr {{cmd}} {{instanceName}} node_env={{environment}}
      h) Help
      q) Quit
        Default <= d
    : `).then((choice) => {
    prompt.close();
    if (choice && choice === 'd' || !choice) {
      processedArgs._[0] = 'i'
      selectedinstance.instanceName = processedArgs._[1] = processedArgs._[1] || 'chess'
      selectedinstance.node_env = processedArgs.node_env = (process.env.NODE_ENV && process.env.NODE_ENV.trim()) || processedArgs.node_env || 'development'
      selectedinstance.reposerver = 'https://git.bbh.org.in'
      getManifest() // PB : TODO -- acquire the manifest directly from http url instead of clone before cloning the config. Since
      // This is because the manifest at any server location can redirect to the preferred server.. 
    }
    else if (choice === 'h') {
      processedArgs._[0] = 'h'
      fs.writeFileSync('run.done', 'noop help');
      console.log(elxr.help()); process.exit()
    }
    else if (choice === 'n' || choice === 'i') {
      var p1 = cli.prompter;
      return p1.ask(`Enter Instance Name ( <= ${selectedinstance.instanceName} ) : `).then(function (instanceName) {
        processedArgs._[0] = 'i'
        selectedinstance.instanceName = processedArgs._[1] = instanceName || selectedinstance.instanceName;
        return p1.ask(`Enter Environment ( <= ${selectedinstance.node_env} ) : `).then(function (node_env) {
          selectedinstance.node_env = processedArgs.node_env = node_env || selectedinstance.node_env
          if (choice === 'n') {
            selectedinstance.reposerver = 'https://git.bbh.org.in'
            console.warn(
              chalk.magenta('No Option Available. Your account may not have privileges. You can request here http://git.bbh.org.in/chess'))
            process.exit();
          }

          return p1.ask(`Enter preferred repo server ( <= ${selectedinstance.reposerver || selectedinstance.reposervers[0]} ) : `).then(function (reposerver) {
            p1.close()
            selectedinstance.reposerver = reposerver || selectedinstance.reposervers[0] || 'https://git.bbh.org.in'
          })
        })
      })
    } else if (choice === 'c') {
      var p1 = cli.prompter;
      return p1.ask(`Enter Instance Name ( <= ${selectedinstance.instanceName} ) : `).then(function (instanceName) {
        selectedinstance.instanceName = processedArgs._[1] = instanceName || selectedinstance.instanceName
        return p1.ask(`Enter Environment ( <= ${selectedinstance.node_env} ) : `).then(function (node_env) {
          selectedinstance.node_env = processedArgs.node_env = node_env || selectedinstance.node_env
          return p1.ask(`Enter cmd : 
      p) pull
        Default <= p
      : `).then(function (cmd) {
            if (!cmd || cmd === 'p') {
              processedArgs._[0] = 'pull'
            }
            else processedArgs._[0] = cmd
            return p1.ask(`Enter preferred repo server ( <= ${selectedinstance.reposerver || selectedinstance.reposervers[0]} ) : `).then(function (reposerver) {
              selectedinstance.reposerver = reposerver || selectedinstance.reposervers[0] || 'https://git.bbh.org.in'
              p1.close()
            })
          })
        })
      })
    } else {
      console.log(chalk.gray(`Default option not exercised. Please follow manual instructions to customize your instance here http://git.bbh.org.in/chess and try again.`));
      fs.writeFileSync('run.log', ', ' + JSON.stringify({ success: 'quit without execution' }), { 'flag': 'a+' })
      fs.writeFileSync('run.done', 'noop quit');
      process.exit()
    }
  })
}

var acquireConfig = function (selected, chessinstances) {

  var configrepo = selected.instanceName + '-config-' + selected.node_env;

  return performPull(configrepo).then(() => {
    var manifestpath = path.normalize(selected.root + '/' + selected.instanceName + '-config-' + selected.node_env + '/repo-manifest');
    repomanifest = require(manifestpath)()
    chessinstances = chessinstances || {};
    chessinstances[selected.instanceName] = chessinstances[selected.instanceName] || {}
    chessinstances[selected.instanceName][selected.node_env] = chessinstances[selected.instanceName][selected.node_env] || {}
    chessinstances['current_run'] = { instanceName: selected.instanceName, node_env: selected.node_env }
    // Config from server always override merges into selection ecept for the current selection.
    selectedinstance = utils.assign(chessinstances[selected.instanceName][selected.node_env], selected, repomanifest)
    fs.writeFileSync(instanceroot + '/chessinstances.js', 'module.exports = ' + JSON.stringify(chessinstances, null, 2) + '', { 'flag': 'w' })
    // PB : TODO -- We should probably write the new server config also...
    selectedinstance.reposerver = selectedinstance.reposerver || selectedinstance.reposervers[0] // PB : TODO -- Attempt first one that is available and online...
    ENV.NODE_ENV = selectedinstance.node_env;
  })
  .catch((e) => {
    console.error(e)
    console.error('Config acquisition failed.')
  })
}

var launchpath = process.cwd().replace(/\\/, '/')
var thisscriptdir = __dirname
var instanceroot = launchpath;
var detectInstance = function () {
  console.log(`launchpath = ${launchpath}`)
  console.log(`thisscriptdir = ${thisscriptdir}`)

  var root = launchpath;

  // We need a reference to the root director for elxr cli to be properly oriented.
  if ((launchpath + path.normalize('/elxr')) === thisscriptdir) {
    // We ran unbuilt from the proper root with elxr subfolder.
    console.log(`Instance Path : ${root}`)
  }
  else {
    if (launchpath === thisscriptdir) {
      // Same directory doesn't mean we are being run from elxr directory or the root directory. 
      // It could be a standalone elxr build which may or maynot be in the proper location.
      if (BUILD_VERSION.indexOf('Version: {version} - built on {date}') > -1) {
        // Unbuilt therefore we are in the elxr directory.
        root = path.normalize(launchpath + '/..');
      }
      else {
        // Built version.
        // check if we have a elxr subfolder.
        if (fs.existsSync(launchpath + '/..' + path.normalize('/elxr'))) {
          // Probably in the right place.        
          root = path.normalize(launchpath + '/..');
        }
        else {
          // Assume launchpath is meaningless.
          // Figure it out from the input instance name and environment parameters if we are in the right location.
          root = path.normalize(launchpath + '/' + processedArgs._[1] + '/' + processedArgs.node_env)
        }
      }
    }
  }
  instanceroot = root.replace(/\\/, '/');
  __default.root = root;
  return Promise.resolve(__default);
}

// 
var __default = {

  // Default is public server only.
  // All public repos are by default available.
    reposervers: ['https://git.bbh.org.in']
  , repos: [
      'setup'
    , 'elxr'
    , 'loopback-connector-mysql'
    , 'loopback-jsonapi-model-serializer'
    , 'loopback-component-jsonapi'
    , 'ember-service-worker'
    , 'ember-service-worker-asset-cache'
    , 'ember-service-worker-cache-fallback'
    , 'ember-service-worker-index'
    , 'ember-sw-client-route'
  ]

  , elevated: []
  , exludeMergeRepos: {}
  , instanceName: 'chess'
  // Runas windowshta clobbers and removes the NODE_ENV !!! We therefore pass it in.
  , node_env: 'development'
}

var __interactve_promts = {
    get reposerver(){
    return cli.prompt(this.reposervers, 'git default repo').then(reposerver => {
      Object.defineProperty(this, 'reposerver', {
        value: reposerver,
        writable: false,
        configurable : true
      });
      return reposerver
    })
  }
  , set reposerver(reposerver){
    Object.defineProperty(this, 'reposerver', {
      value: reposerver,
      writable: false,
      configurable : true
    });
    return reposerver
  }
}

var downloadsdir = '../Downloads';
var prerequisites = [
  {
    shellcmd: 'git',
    url: 'https://github.com/git-for-windows/git/releases/download/v2.31.0.windows.1/Git-2.31.0-64-bit.exe'
    , installer: 'Git-2.31.0-64-bit.exe'
    , installcmd: ['cmd', ['/c', 'start',
      '/WAIT', path.resolve(downloadsdir + '/' + 'Git-2.31.0-64-bit.exe')
      , '/VERYSILENT'
      // , '/MERGETASKS=!runcode' // This is required only for vscode...
    ]]
    , preinstallsteps: function() {
      var prompt = cli.prompter;
      var steps = [
        () => {
          if (!existsSync(downloadsdir + '/' + this.installer)) {
            return nodeShellExec(`${selectedinstance.root}/.elxr/run-${runtimestamp}/download.bat`, [this.url, downloadsdir + '/' + this.installer])
          }
          else return Promise.resolve(true)
        }
      ]
      var prompts = [
          () => prompt.ask(`git user name : ( <= ${gitUser} )`).then((user) => { gitUser = user; })
        , () => prompt.ask(`git email : ( <= ${gitEmail} )`).then((email) => { gitEmail = email; })
      ]
      return any([any(steps), any(prompts)]).then(() => { prompt.close() })
    }
    , installsteps: function () {
      return any([this.installcmd].map(callsheltask))
    }
    , postinstallsteps: function(){
      
      var prompt = cli.prompter;
      
      var gitUser = 'guest';
      var gitEmail = 'guest@bbh.org.in';
      var prompts = [];
      prompts.push(
        ()=>{
          var choices = { 0 : 'guest', 1 : 'chessdemo' }
          return cli.prompt(choices, 'git user name').then(gituser => gitUser = gituser)
        }
      )

      prompts.push(
        ()=>{
          var choices = { 0 : 'guest@bbh.org.in', 1 : 'chessdemo@bbh.org.in' }
          return cli.prompt(choices, 'git user email').then(gitemail => gitEmail = gitemail)
        }
      )

      return any(prompts).then(()=>{
        var steps = [
          ['git', ['config', '--global', '--add', 'user.name', `${gitUser}`]]
          , ['git', ['config', '--global', '--add', 'user.email', `${gitEmail}`]]
        ]
        return any(steps.map(callsheltask)).then(() => { 

        })
      });
    }
    , install: function () {
      return any([ /*this.preinstallsteps,*/ this.installsteps.bind(this), this.postinstallsteps.bind(this)])
    }
    , verifyAndInstall : function(){
      return getTaskCheckExists(this.shellcmd, { ignorefailures: true })().then((exists) => {
        if(exists) {
          // return any(['git', ['config', '--global', '-l']].map(callsheltask))
          return this.getUser(null, this.postinstallsteps.bind(this))
        }
        return this.install();
      });
    }
    , getUser : function(repo, onNoResult){
      
      
      onNoResult = onNoResult || function(){return false}
      var globalOrLocal = '--global';
      if(!repo) globalOrLocal = '--global';
      else globalOrLocal = '--local'

      return any([['git', ['config', globalOrLocal, '--get-all', 'user.name']]].map(callsheltask)).then((result)=>{
        // not yet configured.
        if(!result.success) return onNoResult()
        else {
          var users = result.messages[0].trim().split('\n');
          if(users.length === 0 ||
              users.length === 1 && users[0] === 'guest') {
            
            return onNoResult()
          }
          else return users[0]; // PB : TODO == We should probably prompt with all the users available for selection ! 
        }
      })
      .catch((e)=>{ 
        console.log(e) 
        return onNoResult()
      })
    }
  }
  ,
  {
    shellcmd: 'node',
    url: 'https://nodejs.org/dist/v14.16.0/node-v14.16.0-x64.msi'
    , installer: 'node-v14.16.0-x64.msi'
    , installcmd: ['MSIEXEC.exe', ['/i'
      , path.resolve(downloadsdir + '/' + 'node-v14.16.0-x64.msi')
      , 'ACCEPT=YES', '/passive']]
    , install : function() { return any([this.installcmd].map(callsheltask)).then(() => { }) }
  }
]

prerequisites.forEach(p=>{ prerequisites[p.shellcmd] = p })

function ensureDirectoryExistence(filePath) {
  var dirname = path.dirname(filePath);
  if (fs.existsSync(dirname)) {
    return filePath;
  }
  ensureDirectoryExistence(dirname);
  fs.mkdirSync(dirname);
  return filePath;
}

var mainTasks = [];
function verifyAndInstallPrerequisites() {
  fs.writeFileSync(ensureDirectoryExistence(path.normalize(`${selectedinstance.root}/${downloadsdir}/readme.txt`)), `${getVersion()} Your local downloads for this instance`)
  
  // PB : TODO include and build from files... using rollup..
  var downloadbatch =
    `::**************************************************************************
  :Download_ <url> <File>
    Powershell.exe ^
    $AllProtocols = [System.Net.SecurityProtocolType]'Ssl3,Tls,Tls11,Tls12'; ^
    [System.Net.ServicePointManager]::SecurityProtocol = $AllProtocols; ^
    (New-Object System.Net.WebClient).DownloadFile('%1','%2')
  exit /b
  ::**************************************************************************`
  fs.writeFileSync(`${selectedinstance.root}/.elxr/run-${runtimestamp}/download.bat`, downloadbatch)

  
  var windowselevate =
    `     
      <html><HTA:APPLICATION  ID="windowselevate" icon="#"/>
      <script language="vbscript">
        document.title = "elxr control panel"
        self.ResizeTo 200,600
        
        Sub Window_Onload
        self.MoveTo (screen.availWidth - (document.body.clientWidth + 40)),10
        End Sub

        Set objShell = CreateObject("WScript.Shell")
        Set objENV = objShell.Environment("Process")
        dim NODE_ENV 
        NODE_ENV = objENV("NODE_ENV")
      </script>

      <script language="javascript">
        //WINDOWSTATE="minimize" SHOWINTASKBAR="no" SYSMENU="no" CAPTION="no"
        // https://devblogs.microsoft.com/scripting/how-can-i-pass-command-line-variables-to-an-hta-when-it-starts/
        // alert(windowselevate.commandLine)
        var args = windowselevate.commandLine.split('"').slice(3);
        // alert(args)
        var processedArgs = { _ : [] }
        var namedArgs = [];
        for(var item in args){
          if(args[item].charAt(0) === '-'){ 
            namedArgs.push(args[item])
            var split = args[item].split('=');
            processedArgs[split[0].slice(2)] = split[1] || true;
          } 
          else processedArgs._.push(args[item]);
        }
        // args = args.forEach(function(item){ })
        // alert('processedArgs._ : ' + processedArgs._);
        // alert(processedArgs.runas);
        
        // PB : TODO -- Convert all the cli args back to string.
        var cargs = (processedArgs.debug ? '--inspect-brk=9228' : '') + ' elxr ' + processedArgs._.join(' ') + ' ' +  namedArgs.join(' ');
        // alert(cargs)
        var shell = new ActiveXObject('shell.application'); 
        // alert('launching node privilged. ' + processedArgs['nodepath']) 
        // shell.ShellExecute('where', 'node', '', '', 10);
        shell.ShellExecute('node', cargs, '', 'runas', 1);
        // shell.ShellExecute(processedArgs['nodepath'], cargs, '', 'runas', 1);
        var fso = new ActiveXObject('Scripting.FileSystemObject');
        
        window.onload = function() {
          document.body.style.backgroundColor = 'black';
          document.body.style.fontFamily = 'arial';
          var log = document.createElement('div');
          log.innerHTML='Please Wait';
          function l(msg){ log.innerHTML+= msg; };
          log.style.color = 'blue';
          log.style.width = '95%';
          log.id = 'log';
          document.body.appendChild(log);  
          
          l('<Br/>Current config : ')
          l('<Br/>NODE_ENV = ' + NODE_ENV)
          l('<Br/>cmd = ' + processedArgs._[0])
          processedArgs._[1] === 'use' ? l('<Br/>using = ' + processedArgs._[2]) : null;
          l('<Br/><Br/>')
          
          var timer = function(){
            l('.');
            if(fso.FileExists("run.done")) close();
            else window.setTimeout(timer, 1000);
          };
          window.setTimeout(timer, 3000);
        };
        
      </script>
      </html>
    
    `
  fs.writeFileSync(`${selectedinstance.root}/.elxr/run-${runtimestamp}/windowselevate.hta`, windowselevate)

  var downloadtasks = [];
  var installtasks = [];
  prerequisites.forEach(preq => {
    downloadtasks.push(getTaskCheckExists(preq.shellcmd, { ignorefailures: true })().then((exists) => {
      if (exists) console.log(`${preq.shellcmd} exists`)
      else {
        console.log(`${preq.shellcmd} is not installed`)
        return preq.preinstallsteps.call(preq).then(() => {
          installtasks.push(preq.install.bind(preq))
        })
      }
    }))
  })
  return Promise.all(downloadtasks).then(() => { return any(installtasks) })
}


// function updateselection(selected) { selectedinstance = utils.assign(selectedinstance, selected) }
var selectedinstance = null;
var chessinstances = { current_run : {} };
acquireElevationState().then(() => {
  var skipprerequisites = false;
  var clioverrides = { }
  function initinstances(chessinstances, selected) {
    chessinstances.current_run.instanceName = processedArgs._[1] = processedArgs._[1] || chessinstances.current_run.instanceName || selected.instanceName;
    chessinstances.current_run.node_env = processedArgs.node_env = processedArgs.node_env || chessinstances.current_run.node_env || selected.node_env;
    chessinstances[chessinstances.current_run.instanceName] = chessinstances[chessinstances.current_run.instanceName] || {}

    // Override sequence.
    // __default, chessinstances[current_run], instanceName-config-development, cliargs, interactve_promts
    selectedinstance = Object.assign(
        selected
      , chessinstances[chessinstances.current_run.instanceName][chessinstances.current_run.node_env]
      , clioverrides
      // , __interactve_promts -- Cant just override. Also need selectedinstance to be ready...
    );
    repomanifest = selectedinstance
    return chessinstances
  }
  function acquirelocalinstances(selected){
    var chessinstances = utils.assign(require(path.normalize(selected.root + '/chessinstances.js')));
    return chessinstances
  }


  var noprerequisites = {
    add : true
  }
  var skipprereqs = {}
  var maintask = () => {
    
    // Default cmd to run !
    processedArgs._[0] === processedArgs._[0] || 'pull';  
    // selectedinstance.reposerver = repomanifest.reposervers[0] // PB : TODO -- Attempt first one that is available and online from all that are available...
      
    if(!noprerequisites[processedArgs._[0]]
        && !skipprereqs[processedArgs._[0]]
      ) {
      return prerequisites.git.verifyAndInstall().then(()=>{
        var e = { message : 'verifyAndInstall', success : true}
        return acquireConfig(selectedinstance, chessinstances).catch((err) => {
          e = err;
          console.error('Chosen cofiguraton failed or not found. Fix config and rerun or chose another.')
          console.error(err)
        }).then(() => { return elxrworker(true) })
        // .finally(()=>{
        //   fs.writeFileSync('run.log', ', ' + JSON.stringify({ error: e.message }), { 'flag': 'a+' })
        //   if(!e.success) fs.writeFileSync('run.done', 'error');
        //   // return process.exit()
        // })
      })
    }
    else {
      console.log('cmd has no preqs or has been configured to skip preqs')
      return elxrworker()
    }

  }

  const retaincount = 2
  var min = runtimestamp;
  var collect = []
  

  return detectInstance().then((detectedInstance)=>{

    processedArgs._[1] ? clioverrides.instanceName = processedArgs._[1]: null;
    processedArgs.node_env ? clioverrides.node_env = (process.env.NODE_ENV && process.env.NODE_ENV.trim()) || processedArgs.node_env 
      : (process.env.NODE_ENV && process.env.NODE_ENV.trim()) ? clioverrides.node_env = (process.env.NODE_ENV && process.env.NODE_ENV.trim()): null;
    
    selectedinstance = Object.assign(detectedInstance, clioverrides);
    var todo = Promise.resolve(true);
    try {
      chessinstances = acquirelocalinstances(selectedinstance);
      initinstances(chessinstances, selectedinstance)
    }
    catch (e) {
      console.error(e)
      // No local instances config found. We acquire user choices and proceed to reattempt.
      initinstances(chessinstances, selectedinstance)

      var prompts = [];
      Object.keys(__interactve_promts).forEach(k => { 
        if(!selectedinstance[k]) {
          prompts.push(async ()=>{ 
            Object.defineProperty(selectedinstance, k, Object.getOwnPropertyDescriptor(__interactve_promts, k));
            return await selectedinstance[k] 
          })
        }
      })
        
      todo = any(prompts).then(()=>{ return selectedinstance })
      
      if(!processedArgs._[0] || !selectedinstance.node_env || !selectedinstance.instanceName){
        // Weve been told what to do.
        todo = acquireChoices(selectedinstance)
      }
  
      todo = todo.then(() => {
        try {
          chessinstances = acquirelocalinstances(selectedinstance)
          initinstances(chessinstances, selectedinstance)
        }
        catch (e) {
          console.error(e)
          console.log('No local instances config found in current root = ' + selectedinstance.root);
          console.log('A config will be createed with the instance and environment chosen...')
          // return (async ()=>{return await __default.reposerver})().then(()=>{
          //   // selectedinstance = Object.assign(detectedInstance, clioverrides);
          //   return selectedinstance = Object.assign(__default, selectedinstance);
          // })
          return selectedinstance
        }
      })
    }

    return todo
  })
  .then(()=>{

    if(!__isElevated) {
      ensureDirectoryExistence(`${selectedinstance.root}/.elxr/readme.txt`)
      // collect garbage
      return dirs( (dir)=>{
        var matches = /run-(.*)/gm.exec(dir.name)
        if(matches) {
          if(+(matches[1]) < min) {
            min = matches[1]
            collect.splice( 0, 0, matches[1] ) 
          }
          else collect.push(matches[1])
        }
  
      }, `${selectedinstance.root}/.elxr` ).then(()=>{
        // delete garbage
        if(collect.length > retaincount) {
  
          var asyncs = [];
          while((collect.length - asyncs.length) > retaincount) {
            asyncs.push(getShellTask('rm',['-rf', `run-${collect[asyncs.length]}`], { cwd : `${selectedinstance.root}/.elxr` })());
          }
          return Promise.all(asyncs)
        }
        else return true
      })
    }
    else return true;
  })
  .then(()=>{
    // PB : TODO -- Keep only the last n runs...
    // Currently it retains 2*n when proc needs to be relaunched in elevated mode !!!
    ensureDirectoryExistence(`${selectedinstance.root}/.elxr/run-${runtimestamp}/download.bat`)
    
    if (!skipprerequisites && !__isElevated) mainTasks.push(verifyAndInstallPrerequisites);
    mainTasks.push(maintask)
    return any(mainTasks);
  })
})

// detect if alread installed -> Take no action.
// download if no installer avalable -> next()
// install 
function chackandinstall(items) {
  var tasks = []
  items.forEach(item => {
    tasks.push(getTaskCheckExists(item.shellcommand || prerequisites[item]))
  })

  return Promise.all(tasks).then(existances => {
    existances.forEach((exists, i) => {
      if (!exists) {
        return downloadandinstall([items[i]])
      }
    })
  })
}

function downloadandinstall(items) {
  var tasks = []
  items.forEach(item => {
    tasks.push(getTaskDownload(item))
  })
  return Promise.all(tasks)
}

// Sample instances config.
// var instances = {
//   "elixir": {
//     "production": {
//       "reposervers": ["http://git.bbh", "https://git.bbh.org.in"]
//       , "repos": ["ember-masonry-grid", "client", "elixir-client"]
//       , "exludeMergeRepos": {
//         "elixir-config-development": true, "elixir-config-test": true
//         , "elixir-config-production": true, "elixir-data": true
//       }
//       , "instanceName": "elixir", "node_env": "production"
//     }
//   }, 
//   "current_run": { "instanceName": "elixir", "node_env": "production" }
// }

// ,([^\}^\S\r]*?\}) // Regexp to eliminate extra comma at the end of an array or an object...