@gkalpak/aliases 0.9.4 → 0.10.0

package/lib/alias-scripts/gcoghpr.js

@@ -1,19 +1,73 @@
 /* eslint-disable max-classes-per-file */
-'use strict';
-
 // Imports
-const {commandUtils} = require('@gkalpak/cli-utils');
-const chalk = require('chalk');
+import {get as httpsGet} from 'node:https';
+import {basename} from 'node:path';
+import {createInterface} from 'node:readline';
+
+import {commandUtils} from '@gkalpak/cli-utils';
+import chalk from 'chalk';
+
+import {ALIASES, PR_LOCAL_BRANCH_PREFIX, PR_REMOTE_ALIAS_PREFIX, VERSION_STAMP} from '../constants.js';
 
-// Constants
-const _PR_REMOTE_ALIAS_PREFIX = 'gcoghpr';
-const _PR_LOCAL_BRANCH_PREFIX = 'gcoghpr';
 
-const GH_TOKEN_NAME = 'GITHUB_ACCESS_TOKEN';
-const PR_LOCAL_BRANCH_TOP = `${_PR_LOCAL_BRANCH_PREFIX}-top`;
-const PR_LOCAL_BRANCH_BASE = `${_PR_LOCAL_BRANCH_PREFIX}-base`;
+// Constants
+const internal = {
+  _GH_TOKEN_NAME: 'GITHUB_ACCESS_TOKEN',
+  _PR_LOCAL_BRANCH_BASE: `${PR_LOCAL_BRANCH_PREFIX}-base`,
+  _PR_LOCAL_BRANCH_TOP: `${PR_LOCAL_BRANCH_PREFIX}-top`,
+  get _Executor() { return Executor; },
+  get _GitHubUtils() { return GitHubUtils; },
+  get _Logger() { return Logger; },
+
+  _httpsGet,
+  _rlCreateInterface,
+};
 
 // Classes
+class Executor {
+  constructor(logger, baseConfig = {}, debugMode = false) {
+    this._logger = logger;
+    this._baseConfig = baseConfig;
+    this._debugMode = debugMode;
+  }
+
+  exec(cmd, config) {
+    config = Object.assign({}, this._baseConfig, config);
+
+    const cmdSep = ' && ';
+    const printableCmd = cmd.
+      split(cmdSep).
+      filter(c => !/^(?:echo|node (?:-p|--print)) /.test(c)).
+      join(cmdSep);
+
+    if (this._debugMode) {
+      this._logger.debug(`Running command '${cmd}' (config: ${JSON.stringify(config)})...`);
+    }
+    this._logger.info(`RUN: ${printableCmd}`);
+
+    return commandUtils.spawnAsPromised(cmd, config);
+  }
+
+  async execForOutput(cmd, config) {
+    config = Object.assign({}, config, {returnOutput: true});
+    const output = await this.exec(cmd, config);
+
+    return output.trim();
+  }
+
+  async execWithStyle(color, cmd, config) {
+    const tempStyle = this._logger.getTempStyle(color);
+    const preCmd = `node --print ${JSON.stringify(`'\b${tempStyle.open}'`)}`;
+    const resetStyle = () => process.stdout.write(tempStyle.close);
+
+    try {
+      return await this.exec(`${preCmd} && ${cmd}`, config);
+    } finally {
+      resetStyle();
+    }
+  }
+}
+
 /**
  * @class Gcoghpr
  *
@@ -25,14 +79,10 @@ const PR_LOCAL_BRANCH_BASE = `${_PR_LOCAL_BRANCH_PREFIX}-base`;
  * new Gcoghpr().run(['12345'])
  * ```
  */
-class _Gcoghpr {
-  get _rl() { return this._lazyLoader.get('readline'); }
-  get _constants() { return this._lazyLoader.get('../constants'); }
-
+class Gcoghpr {
   constructor() {
-    this._logger = new exps._Logger();
-    this._lazyLoader = new exps._LazyLoader();
-    this._ghUtils = new exps._GitHubUtils(this._logger, this._lazyLoader);
+    this._logger = new internal._Logger();
+    this._ghUtils = new internal._GitHubUtils(this._logger);
     this._remoteUrlRe = /^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git|\/)?$/i;
   }
 
@@ -65,67 +115,77 @@ class _Gcoghpr {
    *
    * @return {Promise<void>} - A promise that resolves once all operations have completed.
    */
-  run(runtimeArgs, config = {}) {
+  async run(runtimeArgs, config = {}) {
     if (config.dryrun) {
       this._logger.log('Check out a GitHub pull request on a local branch.');
-      return Promise.resolve();
+      return;
+    }
+
+    const executor = new internal._Executor(this._logger, Object.assign({sapVersion: 2}, config), config.debug);
+    const {prId = null} = this._validateInput(runtimeArgs);
+
+    if (prId === null) {
+      return;
     }
 
-    const executor = new exps._Executor(this._logger, Object.assign({sapVersion: 2}, config), config.debug);
-
-    return Promise.resolve().
-      then(() => this._validateInput(runtimeArgs)).
-      then(({prId}) => prId && Promise.resolve().
-        then(() => this._logger.forceColor('gray')).
-        then(() => executor.execForOutput('git remote get-url upstream || git remote get-url origin')).
-        then(upstreamUrl => {
-          const [, upstreamUser, upstreamRepo] = this._remoteUrlRe.exec(upstreamUrl);
-          const upstreamInfo = {user: upstreamUser, repo: upstreamRepo, url: upstreamUrl};
-
-          if (config.debug) {
-            this._logger.debug(`Upstream info: ${JSON.stringify(upstreamInfo)}`);
-          }
-
-          return this._getPrInfo(upstreamInfo, prId);
-        }).
-        then(prInfo => {
-          const localBranchSuffix = (prId.indexOf(':') !== -1) ? prInfo.branch : `pr${prId}`;
-          const localBranch = `${_PR_LOCAL_BRANCH_PREFIX}-${localBranchSuffix}`;
-          const remoteAlias = `${_PR_REMOTE_ALIAS_PREFIX}-${prInfo.author}`;
-
-          if (config.debug) {
-            this._logger.debug(`PR info: ${JSON.stringify(prInfo)}`);
-            this._logger.debug(`Local branch: ${localBranch}`);
-          }
-
-          return {...prInfo, localBranch, remoteAlias};
-        }).
-        then(({branch, originUrl, commits, localBranch, remoteAlias}) => Promise.resolve().
-          then(() => executor.exec(`git show-ref --heads --quiet ${localBranch}`).
-            then(() => this._confirmOverwriteBranch(localBranch), () => undefined)).
-          then(() => executor.execForOutput('git rev-parse --abbrev-ref HEAD')).
-          then(currentBranch =>
-            (currentBranch === localBranch) &&
-              executor.execForOutput(this._constants.ALIASES.git.gdefb.getSpec().command).
-                then(defaultBranch => executor.exec(`git checkout ${defaultBranch}`))).
-          then(() => executor.exec(`git remote remove ${remoteAlias} || true`)).
-          then(() => executor.exec(`git remote add ${remoteAlias} ${originUrl}`)).
-          then(() => executor.exec(`git fetch --no-tags ${remoteAlias} ${branch}`)).
-          then(() => executor.exec(`git branch --force --track ${localBranch} ${remoteAlias}/${branch}`)).
-          then(() => executor.exec(`git branch --force ${PR_LOCAL_BRANCH_TOP} ${localBranch}`)).
-          then(() => executor.exec(`git branch --force ${PR_LOCAL_BRANCH_BASE} ${localBranch}~${commits || 0}`)).
-          then(() => executor.exec(`git checkout ${localBranch}`)).
-          then(() => this._reportSuccess(localBranch, commits, executor)).
-          then(() => this._logger.forceColor(null))).
-        catch(err => {
-          this._logger.forceColor(null);
-          return Promise.reject(err);
-        }));
+    try {
+      this._logger.forceColor('gray');
+
+      const upstreamUrl = await executor.execForOutput('git remote get-url upstream || git remote get-url origin');
+      const [, upstreamUser, upstreamRepo] = this._remoteUrlRe.exec(upstreamUrl);
+      const upstreamInfo = {user: upstreamUser, repo: upstreamRepo, url: upstreamUrl};
+
+      if (config.debug) {
+        this._logger.debug(`Upstream info: ${JSON.stringify(upstreamInfo)}`);
+      }
+
+      const prInfo = await this._getPrInfo(upstreamInfo, prId);
+      const localBranchSuffix = (prId.indexOf(':') !== -1) ? prInfo.branch : `pr${prId}`;
+      const localBranch = `${PR_LOCAL_BRANCH_PREFIX}-${localBranchSuffix}`;
+      const remoteAlias = `${PR_REMOTE_ALIAS_PREFIX}-${prInfo.author}`;
+
+      if (config.debug) {
+        this._logger.debug(`PR info: ${JSON.stringify(prInfo)}`);
+        this._logger.debug(`Local branch: ${localBranch}`);
+      }
+
+      let localBranchExists;
+
+      try {
+        await executor.exec(`git show-ref --heads --quiet ${localBranch}`);
+        localBranchExists = true;
+      } catch {
+        localBranchExists = false;
+      }
+
+      if (localBranchExists) {
+        await this._confirmOverwriteBranch(localBranch);
+      }
+
+      const currentBranch = await executor.execForOutput('git rev-parse --abbrev-ref HEAD');
+
+      if (currentBranch === localBranch) {
+        const defaultBranch = await executor.execForOutput(ALIASES.git.gdefb.getSpec().command);
+        await executor.exec(`git checkout ${defaultBranch}`);
+      }
+
+      await executor.exec(`git remote remove ${remoteAlias} || true`);
+      await executor.exec(`git remote add ${remoteAlias} ${prInfo.originUrl}`);
+      await executor.exec(`git fetch --no-tags ${remoteAlias} ${prInfo.branch}`);
+      await executor.exec(`git branch --force --track ${localBranch} ${remoteAlias}/${prInfo.branch}`);
+      await executor.exec(`git branch --force ${internal._PR_LOCAL_BRANCH_TOP} ${localBranch}`);
+      await executor.exec(`git branch --force ${internal._PR_LOCAL_BRANCH_BASE} ${localBranch}~${prInfo.commits || 0}`);
+      await executor.exec(`git checkout ${localBranch}`);
+
+      await this._reportSuccess(localBranch, prInfo.commits, executor);
+    } finally {
+      this._logger.forceColor(null);
+    }
   }
 
   _confirmOverwriteBranch(branch) {
     return new Promise((resolve, reject) => {
-      const rlInstance = this._rl.createInterface(process.stdin, process.stdout);
+      const rlInstance = internal._rlCreateInterface(process.stdin, process.stdout);
       const question = chalk.yellow(
           `Branch '${branch}' does already exist.\n` +
           `Overwrite it? ${chalk.white('[y/N]')} `);
@@ -137,18 +197,17 @@ class _Gcoghpr {
     });
   }
 
-  _getPrInfo(upstreamInfo, prId) {
-    const prDataPromise = (prId.indexOf(':') !== -1) ?
+  async _getPrInfo(upstreamInfo, prId) {
+    const {commits, label} = prId.includes(':') ?
       // `author:branch`
-      Promise.resolve({commits: 0, label: prId}) :
+      {commits: 0, label: prId} :
       // `12345`
-      this._ghUtils.getPr(upstreamInfo, prId).then(({commits, head}) => ({commits, label: head.label}));
+      await this._ghUtils.getPr(upstreamInfo, prId).then(({commits, head}) => ({commits, label: head.label}));
 
-    return prDataPromise.then(({commits, label}) => {
-      const [author, branch] = label.split(':');
-      const originUrl = `https://github.com/${author}/${upstreamInfo.repo}.git`;
-      return {author, branch, originUrl, commits};
-    });
+    const [author, branch] = label.split(':');
+    const originUrl = `https://github.com/${author}/${upstreamInfo.repo}.git`;
+
+    return {author, branch, originUrl, commits};
   }
 
   _getPrintCommand(message) {
@@ -158,20 +217,21 @@ class _Gcoghpr {
       join(' && ');
   }
 
-  _reportSuccess(localBranch, commits, executor) {
+  async _reportSuccess(localBranch, commits, executor) {
     let ready = Promise.resolve();
     const commands = [];
 
     const messageMain = `\nFetched PR into local branch '${chalk.green(localBranch)}'`;
     const messageExt = !commits ?
       '.' :
-      ` (and also branch range '${chalk.cyan(PR_LOCAL_BRANCH_BASE)}..${chalk.cyan(PR_LOCAL_BRANCH_TOP)}').\n` +
+      ' (and also branch range ' +
+        `'${chalk.cyan(internal._PR_LOCAL_BRANCH_BASE)}..${chalk.cyan(internal._PR_LOCAL_BRANCH_TOP)}').\n` +
       '\n' +
       `PR commits (${commits})\\n---`;
     commands.push(this._getPrintCommand(`${messageMain}${messageExt}`));
 
     if (commits) {
-      const gl1RawCmd = this._constants.ALIASES.git.gl1.getSpec().command;
+      const gl1RawCmd = ALIASES.git.gl1.getSpec().command;
       const gl1Args = [`-${commits + 1}`];
 
       ready = ready.
@@ -179,11 +239,12 @@ class _Gcoghpr {
         then(gl1Cmd => commands.push(gl1Cmd));
     }
 
-    return ready.then(() => executor.execWithStyle(null, commands.join(' && ')));
+    await ready;
+    return executor.execWithStyle(null, commands.join(' && '));
   }
 
   _usage() {
-    const scriptName = __filename.slice(__dirname.length +1).replace(/\.js$/, '');
+    const scriptName = basename(import.meta.url).replace(/\.js$/, '');
     const command = chalk.bgBlack.green(`${scriptName} @(<pr-number>|<author>:<branch>)`);
     const usageMessage = `${chalk.cyan('Usage:')} ${command}`;
 
@@ -203,7 +264,7 @@ class _Gcoghpr {
         this._usage();
         return {};
       case 1:
-        if ((prId.indexOf(':') === -1) && !/^\d+$/.test(prId)) {
+        if (!prId.includes(':') && !/^\d+$/.test(prId)) {
           onError(`Unexpected PR identifier: ${prId}`);
           break;
         }
@@ -216,84 +277,38 @@ class _Gcoghpr {
   }
 }
 
-class Executor {
-  constructor(logger, baseConfig = {}, debugMode = false) {
-    this._logger = logger;
-    this._baseConfig = baseConfig;
-    this._debugMode = debugMode;
-  }
-
-  exec(cmd, config) {
-    config = Object.assign({}, this._baseConfig, config);
-
-    const cmdSep = ' && ';
-    const printableCmd = cmd.
-      split(cmdSep).
-      filter(c => !/^(?:echo|node (?:-p|--print)) /.test(c)).
-      join(cmdSep);
-
-    if (this._debugMode) {
-      this._logger.debug(`Running command '${cmd}' (config: ${JSON.stringify(config)})...`);
-    }
-    this._logger.info(`RUN: ${printableCmd}`);
-
-    return commandUtils.spawnAsPromised(cmd, config);
-  }
-
-  execForOutput(cmd, config) {
-    config = Object.assign({}, config, {returnOutput: true});
-    return this.exec(cmd, config).then(output => output.trim());
-  }
-
-  execWithStyle(color, cmd, config) {
-    const tempStyle = this._logger.getTempStyle(color);
-    const preCmd = `node --print ${JSON.stringify(`'\b${tempStyle.open}'`)}`;
-    const resetStyle = () => process.stdout.write(tempStyle.close);
-
-    const promise = this.exec(`${preCmd} && ${cmd}`, config);
-    promise.then(resetStyle, resetStyle);
-
-    return promise;
-  }
-}
-
 class GitHubUtils {
-  get _https() { return this._lazyLoader.get('https'); }
-  get _url() { return this._lazyLoader.get('url'); }
-  get _constants() { return this._lazyLoader.get('../constants'); }
-
-  constructor(logger, lazyLoader) {
+  constructor(logger) {
     this._logger = logger;
-    this._lazyLoader = lazyLoader;
     this._baseUrl = 'https://api.github.com/';
     this._shownTokenWarning = false;
   }
 
-  get(path) {
-    const url = this._baseUrl + path;
-    const ghToken = process.env[GH_TOKEN_NAME] || '';
+  async get(path) {
+    const url = `${this._baseUrl}${path}`;
+    const ghToken = process.env[internal._GH_TOKEN_NAME] || '';
     const options = {
       headers: {
         Authorization: ghToken && `token ${ghToken}`,
-        'User-Agent': this._constants.VERSION_STAMP.replace(/\s/g, '_'),
+        'User-Agent': VERSION_STAMP.replace(/\s/g, '_'),
       },
     };
 
     if (!ghToken && !this._shownTokenWarning) {
       this._shownTokenWarning = true;
       this._logger.warn(
-          `No GitHub access token found in \`${GH_TOKEN_NAME}\` environment variable.\n` +
+          `No GitHub access token found in \`${internal._GH_TOKEN_NAME}\` environment variable.\n` +
           'Proceeding anonymously (and subject to rate-limiting)...');
     }
 
-    return this._httpsGet(url, options).then(responseText => {
-      try {
-        return JSON.parse(responseText);
-      } catch (err) {
-        this._logger.error(`Response:\n${responseText}`);
-        throw err;
-      }
-    });
+    const responseText = await this._httpsGet(url, options);
+
+    try {
+      return JSON.parse(responseText);
+    } catch (err) {
+      this._logger.error(`Response:\n${responseText}`);
+      throw err;
+    }
   }
 
   getPr({user: upstreamUser, repo: upstreamRepo}, prNumber) {
@@ -303,32 +318,19 @@ class GitHubUtils {
   _httpsGet(url, options = {}) {
     return new Promise((resolve, reject) => {
       this._logger.info(`GET: ${url} (options: {${Object.keys(options).join(', ')}})`);
-
       let data = '';
-      this._https.
-        // Do not use the `get(url, options, cb)` signature,
-        // to remain compatible with versions older than 10.9.0.
-        get({...this._url.parse(url), ...options}, res => res.
-          on('error', reject).
-          on('data', d => data += d).
-          on('end', () => ((200 <= res.statusCode) && (res.statusCode < 300)) ?
-            resolve(data) :
-            reject(`Request to '${url}' failed (status: ${res.statusCode}):\n${data}`))).
+
+      internal._httpsGet(url, options, res => res.
+        on('error', reject).
+        on('data', d => data += d).
+        on('end', () => ((200 <= res.statusCode) && (res.statusCode < 300)) ?
+          resolve(data) :
+          reject(`Request to '${url}' failed (status: ${res.statusCode}):\n${data}`))).
         on('error', reject);
     });
   }
 }
 
-class LazyLoader {
-  constructor() {
-    this._loaded = Object.create(null);
-  }
-
-  get(dep) {
-    return this._loaded[dep] || (this._loaded[dep] = require(dep));
-  }
-}
-
 class Logger {
   constructor() {
     this._forcedStyle = {
@@ -380,38 +382,23 @@ class Logger {
 }
 
 // Exports
-const exps = module.exports = {
-  PR_LOCAL_BRANCH_PREFIX: _PR_LOCAL_BRANCH_PREFIX,
-
-  PR_REMOTE_ALIAS_PREFIX: _PR_REMOTE_ALIAS_PREFIX,
-
-  Gcoghpr: _Gcoghpr,
-
-  main: __main,
-
-  /** Exposed for testing purposes only. */
-  _GH_TOKEN_NAME: GH_TOKEN_NAME,
+export {
+  Gcoghpr,
+  main,
 
-  /** Exposed for testing purposes only. */
-  _PR_LOCAL_BRANCH_BASE: PR_LOCAL_BRANCH_BASE,
-
-  /** Exposed for testing purposes only. */
-  _PR_LOCAL_BRANCH_TOP: PR_LOCAL_BRANCH_TOP,
-
-  /** Exposed for testing purposes only. */
-  _Executor: Executor,
-
-  /** Exposed for testing purposes only. */
-  _GitHubUtils: GitHubUtils,
+  // Exposed for testing purposes only.
+  internal as _testing,
+};
 
-  /** Exposed for testing purposes only. */
-  _LazyLoader: LazyLoader,
+// Helpers
+function _httpsGet(...args) {
+  return httpsGet(...args);
+}
 
-  /** Exposed for testing purposes only. */
-  _Logger: Logger,
-};
+function _rlCreateInterface(...args) {
+  return createInterface(...args);
+}
 
-// Functions - Definitions
-function __main(runtimeArgs, config) {
-  return new exps.Gcoghpr().run(runtimeArgs, config);
+function main(runtimeArgs, config) {
+  return new Gcoghpr().run(runtimeArgs, config);
 }

package/lib/alias-scripts/nvu.js

@@ -1,15 +1,21 @@
-'use strict';
-
 // Imports
-const {commandUtils} = require('@gkalpak/cli-utils');
-const chalk = require('chalk');
-const utils = require('../utils');
+import {commandUtils} from '@gkalpak/cli-utils';
+import chalk from 'chalk';
+
+import {ALIASES} from '../constants.js';
+import {getPlatform, stripIndentation} from '../utils.js';
+
 
 // Constants
 const PLATFORM_WINDOWS = 'win32';
+const internal = {
+  _nvu,
+};
 
 // Exports
-const exps = module.exports = {
+export {
+  main,
+
   /**
    * @function nvu
    *
@@ -41,32 +47,29 @@ const exps = module.exports = {
    *
    * @return {Promise<void>} - A promise that resolves once switched to the new Node.js version.
    */
-  nvu: _nvu,
+  nvu,
 
-  main: __main,
+  // Exposed for testing purposes only.
+  internal as _testing,
 };
 
-// Functions - Definitions
-function __main(runtimeArgs, config) {
-  return exps.nvu(runtimeArgs, config);
-}
-
-function _nvu(runtimeArgs, config) {
+// Helpers
+async function _nvu(runtimeArgs, config) {
   const branch = runtimeArgs[0];
   const nvmRuntimeArgs = runtimeArgs.slice(1);
-  const buildCmd = getBuildCmdFn(utils.getPlatform(), config.dryrun);
+  const buildCmd = getBuildCmdFn(getPlatform(), config.dryrun);
 
-  return buildCmd(branch, nvmRuntimeArgs, config).then(cmd => {
-    if (config.dryrun) {
-      console.log(cmd);
-      return Promise.resolve();
-    }
+  const cmd = await buildCmd(branch, nvmRuntimeArgs, config);
+
+  if (config.dryrun) {
+    console.log(cmd);
+    return;
+  }
 
-    return commandUtils.run(cmd, nvmRuntimeArgs, config);
-  });
+  return commandUtils.run(cmd, nvmRuntimeArgs, config);
 }
 
-function buildCmdDefault(branch, runtimeArgs) {
+async function buildCmdDefault(branch, runtimeArgs) {
   const hasChainedCmd = runtimeArgs.indexOf('&&') !== -1;
 
   const nvuCmd = `nvu ${branch} "&&" <some-command>`;
@@ -74,8 +77,8 @@ function buildCmdDefault(branch, runtimeArgs) {
   let warnCmd = '';
 
   if (!hasChainedCmd) {
-    //         10        20        30        40        50        60        70|
-    const warning = chalk.yellow(utils.stripIndentation(`
+    //        1|0       2|0       3|0       4|0       5|0       6|0       7|0
+    const warning = chalk.yellow(stripIndentation(`
       WARNING:
         Running 'nvu' like this will not affect the current proccess, only the
         spawned child process. You can still execute a single command using
@@ -90,40 +93,37 @@ function buildCmdDefault(branch, runtimeArgs) {
     warnCmd = `node --print ${JSON.stringify(JSON.stringify(warning))} && `;
   }
 
-  return Promise.resolve(`${warnCmd}. $NVM_DIR/nvm.sh && ${nvmCmd} $*`);
+  return `${warnCmd}. $NVM_DIR/nvm.sh && ${nvmCmd} $*`;
 }
 
-function buildCmdDryrun(platform, branch, nvmRuntimeArgs) {
+async function buildCmdDryrun(platform, branch, nvmRuntimeArgs) {
   const getVersionArgs = (platform === PLATFORM_WINDOWS) ? `${branch}, {{nvls}}` : branch;
   const getVersionSubCmd = `getVersion(${getVersionArgs})`;
 
-  return Promise.resolve(`nvm use {{${getVersionSubCmd}}} ${nvmRuntimeArgs.join(' ')}`.trim());
+  return `nvm use {{${getVersionSubCmd}}} ${nvmRuntimeArgs.join(' ')}`.trim();
 }
 
-function buildCmdForWindows(branch, runtimeArgs, config) {
-  const {ALIASES} = require('../constants');
+async function buildCmdForWindows(branch, _runtimeArgs, config) {
   const nvlsCmd = ALIASES.node.nvls.getSpec().command;
   const nvlsConfig = Object.assign({}, config, {returnOutput: true});
 
-  return commandUtils.
-    run(nvlsCmd, [], nvlsConfig).
-    then(nvlsOutput => {
-      const subVersionCount = 3 - branch.split('.').length;
-      const versionRe = new RegExp(`(?:^|\\D)(${branch}(?:\\.\\d+){${subVersionCount}})`);
-      const versionArr = nvlsOutput.
-        split('\n').
-        map(line => versionRe.exec(line)).
-        filter(Boolean).
-        map(match => match[1].split('.').map(Number)).
-        sort(sortVersionArrays).
-        pop();
-
-      if (!versionArr) {
-        throw new Error(`No installed Node.js version found for '${branch}'.`);
-      }
-
-      return `nvm use ${versionArr.join('.')} $*`;
-    });
+  const nvlsOutput = await commandUtils.run(nvlsCmd, [], nvlsConfig);
+
+  const subVersionCount = 3 - branch.split('.').length;
+  const versionRe = new RegExp(`(?:^|\\D)(${branch}(?:\\.\\d+){${subVersionCount}})`);
+  const versionArr = nvlsOutput.
+    split('\n').
+    map(line => versionRe.exec(line)).
+    filter(Boolean).
+    map(match => match[1].split('.').map(Number)).
+    sort(sortVersionArrays).
+    pop();
+
+  if (!versionArr) {
+    throw new Error(`No installed Node.js version found for '${branch}'.`);
+  }
+
+  return `nvm use ${versionArr.join('.')} $*`;
 }
 
 function getBuildCmdFn(platform, dryrun) {
@@ -137,6 +137,14 @@ function getBuildCmdFn(platform, dryrun) {
   }
 }
 
+function main(runtimeArgs, config) {
+  return nvu(runtimeArgs, config);
+}
+
+function nvu(runtimeArgs, config) {
+  return internal._nvu(runtimeArgs, config);
+}
+
 function sortVersionArrays(a, b) {
   for (let i = 0, ii = a.length; i < ii; ++i) {
     const diff = a[i] - b[i];