appium 2.0.0-beta.25 → 2.0.0-beta.26

package/lib/cli/extension-command.js

@@ -1,47 +1,61 @@
+// @ts-check
 /* eslint-disable no-console */
 
 import _ from 'lodash';
-import NPM from './npm';
-import path from 'path';
-import { fs, util } from '@appium/support';
+import { npm, fs, util } from '@appium/support';
 import { log, spinWith, RingBuffer } from './utils';
-import { SubProcess} from 'teen_process';
+import { SubProcess } from 'teen_process';
 import { INSTALL_TYPE_NPM, INSTALL_TYPE_GIT, INSTALL_TYPE_GITHUB,
-         INSTALL_TYPE_LOCAL } from '../extension-config';
+         INSTALL_TYPE_LOCAL } from '../extension/extension-config';
 
 const UPDATE_ALL = 'installed';
 
 class NotUpdatableError extends Error {}
 class NoUpdatesAvailableError extends Error {}
 
+/**
+ * @template {ExtensionType} ExtType
+ */
 export default class ExtensionCommand {
+  /**
+   * This is the `DriverConfig` or `PluginConfig`, depending on `ExtType`.
+   * @type {ExtensionConfig<ExtType>}
+   */
+  config;
+
+  /**
+   * {@linkcode Record} of official plugins or drivers.
+   * @type {ExtType extends import('../extension/manifest').DriverType ? typeof import('../constants').KNOWN_DRIVERS : typeof import('../constants').KNOWN_PLUGINS}
+   */
+  knownExtensions;
 
   /**
-   * @typedef {Object} ExtensionCommandConstructor
-   * @property {Object} config - the DriverConfig or PluginConfig object used for this command
-   * @property {boolean} json - whether the output of this command should be JSON or text
-   * @property {string} type - DRIVER_TYPE or PLUGIN_TYPE
+   * If `true`, command output has been requested as JSON.
+   * @type {boolean}
    */
+  isJsonOutput;
 
   /**
    * Build an ExtensionCommand
-   *
-   * @param {ExtensionCommandConstructor} opts
-   * @return {ExtensionCommand}
+   * @param {ExtensionCommandOptions<ExtType>} opts
    */
-  constructor ({config, json, type}) {
+  constructor ({config, json}) {
     this.config = config;
-    this.type = type;
     this.isJsonOutput = json;
-    this.npm = new NPM(this.config.appiumHome);
-    this.knownExtensions = {}; // this needs to be overridden in final class
+  }
+
+  /**
+   * `driver` or `plugin`, depending on the `ExtensionConfig`.
+   */
+  get type () {
+    return this.config.extensionType;
   }
 
   /**
    * Take a CLI parse and run an extension command based on its type
    *
    * @param {object} args - a key/value object with CLI flags and values
-   * @return {object} the result of the specific command which is executed
+   * @return {Promise<object>} the result of the specific command which is executed
    */
   async execute (args) {
     const cmd = args[`${this.type}Command`];
@@ -53,7 +67,7 @@ export default class ExtensionCommand {
   }
 
   /**
-   * @typedef {Object} ListArgs
+   * @typedef ListOptions
    * @property {boolean} showInstalled - whether should show only installed extensions
    * @property {boolean} showUpdates - whether should show available updates
    */
@@ -61,8 +75,8 @@ export default class ExtensionCommand {
   /**
    * List extensions
    *
-   * @param {ListArgs} args
-   * @return {object} map of extension names to extension data
+   * @param {ListOptions} opts
+   * @return {Promise<ExtensionListData>} map of extension names to extension data
    */
   async list ({showInstalled, showUpdates}) {
     const lsMsg = `Listing ${showInstalled ? 'installed' : 'available'} ${this.type}s`;
@@ -77,7 +91,7 @@ export default class ExtensionCommand {
         }
       }
       return acc;
-    }, {});
+    }, /** @type {ExtensionListData} */({}));
 
     // if we want to show whether updates are available, put that behind a spinner
     await spinWith(this.isJsonOutput, lsMsg, async () => {
@@ -85,8 +99,7 @@ export default class ExtensionCommand {
         return;
       }
       for (const [ext, data] of _.toPairs(exts)) {
-        const {installed, installType} = data;
-        if (!installed || installType !== INSTALL_TYPE_NPM) {
+        if (!data.installed || data.installType !== INSTALL_TYPE_NPM) {
           // don't need to check for updates on exts that aren't installed
           // also don't need to check for updates on non-npm exts
           continue;
@@ -106,32 +119,40 @@ export default class ExtensionCommand {
 
     for (const [
       name,
-      {installType, installSpec, installed, updateVersion, unsafeUpdateVersion, version, upToDate}
+      data
     ] of _.toPairs(exts)) {
-      let typeTxt;
-      switch (installType) {
-        case INSTALL_TYPE_GIT:
-        case INSTALL_TYPE_GITHUB:
-          typeTxt = `(cloned from ${installSpec})`.yellow;
-          break;
-        case INSTALL_TYPE_LOCAL:
-          typeTxt = `(linked from ${installSpec})`.magenta;
-          break;
-        default:
-          typeTxt = '(NPM)';
+      let installTxt = ' [not installed]'.grey;
+      let updateTxt = '';
+      let upToDateTxt = '';
+      let unsafeUpdateTxt = '';
+      if (data.installed) {
+        const {installType, installSpec, updateVersion, unsafeUpdateVersion, version, upToDate} = data;
+        let typeTxt;
+        switch (installType) {
+          case INSTALL_TYPE_GIT:
+          case INSTALL_TYPE_GITHUB:
+            typeTxt = `(cloned from ${installSpec})`.yellow;
+            break;
+          case INSTALL_TYPE_LOCAL:
+            typeTxt = `(linked from ${installSpec})`.magenta;
+            break;
+          default:
+            typeTxt = '(NPM)';
+        }
+        installTxt = `@${version.yellow} ${('[installed ' + typeTxt + ']').green}`;
+
+        if (showUpdates) {
+          if (updateVersion) {
+            updateTxt = ` [${updateVersion} available]`.magenta;
+          }
+          if (upToDate) {
+            upToDateTxt = ` [Up to date]`.green;
+          }
+          if (unsafeUpdateVersion) {
+            unsafeUpdateTxt = ` [${unsafeUpdateVersion} available (potentially unsafe)]`.cyan;
+          }
+        }
       }
-      const installTxt = installed ?
-        `@${version.yellow} ${('[installed ' + typeTxt + ']').green}` :
-        ' [not installed]'.grey;
-      const updateTxt = showUpdates && updateVersion ?
-        ` [${updateVersion} available]`.magenta :
-        '';
-      const upToDateTxt = showUpdates && upToDate ?
-        ` [Up to date]`.green :
-        '';
-      const unsafeUpdateTxt = showUpdates && unsafeUpdateVersion ?
-        ` [${unsafeUpdateVersion} available (potentially unsafe)]`.cyan :
-        '';
 
       console.log(`- ${name.yellow}${installTxt}${updateTxt}${upToDateTxt}${unsafeUpdateTxt}`);
     }
@@ -139,22 +160,14 @@ export default class ExtensionCommand {
     return exts;
   }
 
-  /**
-   * @typedef {Object} InstallArgs
-   * @property {string} ext - the name or spec of an extension to install
-   * @property {string} installType - how to install this extension. One of the INSTALL_TYPES
-   * @property {string} [packageName] - for git/github installs, the extension node package name
-   */
-
   /**
    * Install an extension
    *
    * @param {InstallArgs} args
-   * @return {object} map of all installed extension names to extension data
+   * @return {Promise<ExtRecord<ExtType>>} map of all installed extension names to extension data
    */
   async install ({ext, installType, packageName}) {
-    log(this.isJsonOutput, `Attempting to find and install ${this.type} '${ext}'`);
-
+    /** @type {ExtData<ExtType>} */
     let extData;
     let installSpec = ext;
 
@@ -167,23 +180,23 @@ export default class ExtensionCommand {
     }
 
     if (installType === INSTALL_TYPE_LOCAL) {
-      const msg = `Linking ${this.type} from local path`;
+      const msg = `Linking ${this.type} from local path into ${this.config.appiumHome}`;
       const pkgJsonData = await spinWith(this.isJsonOutput, msg, async () => (
-        await this.npm.linkPackage(installSpec))
+        await npm.linkPackage(this.config.appiumHome, installSpec))
       );
       extData = this.getExtensionFields(pkgJsonData);
-      extData.installPath = extData.pkgName;
+      log(this.isJsonOutput, `Successfully linked ${extData.pkgName} into ${this.config.appiumHome}`);
     } else if (installType === INSTALL_TYPE_GITHUB) {
       if (installSpec.split('/').length !== 2) {
         throw new Error(`Github ${this.type} spec ${installSpec} appeared to be invalid; ` +
                         'it should be of the form <org>/<repo>');
       }
-      extData = await this.installViaNpm({ext: installSpec, pkgName: packageName});
+      extData = await this.installViaNpm({ext: installSpec, pkgName: /** @type {string} */(packageName)});
     } else if (installType === INSTALL_TYPE_GIT) {
       // git urls can have '.git' at the end, but this is not necessary and would complicate the
       // way we download and name directories, so we can just remove it
       installSpec = installSpec.replace(/\.git$/, '');
-      extData = await this.installViaNpm({ext: installSpec, pkgName: packageName});
+      extData = await this.installViaNpm({ext: installSpec, pkgName: /** @type {string} */(packageName)});
     } else {
       // at this point we have either an npm package or an appium verified extension
       // name. both of which will be installed via npm.
@@ -224,8 +237,8 @@ export default class ExtensionCommand {
       extData = await this.installViaNpm({ext, pkgName, pkgVer});
     }
 
-    const extName = extData[`${this.type}Name`];
-    delete extData[`${this.type}Name`];
+    const extName = extData[/** @type {string} */(`${this.type}Name`)];
+    delete extData[/** @type {string} */(`${this.type}Name`)];
 
     if (this.config.isInstalled(extName)) {
       throw new Error(`A ${this.type} named '${extName}' is already installed. ` +
@@ -243,17 +256,11 @@ export default class ExtensionCommand {
     return this.config.installedExtensions;
   }
 
-  /**
-   * @typedef {Object} InstallViaNpmArgs
-   * @property {string} ext - the name or spec of an extension to install
-   * @property {string} pkgName - the NPM package name of the extension
-   * @property {string} [pkgVer] - the specific version of the NPM package
-   */
-
   /**
    * Install an extension via NPM
    *
    * @param {InstallViaNpmArgs} args
+   * @returns {Promise<ExtData<ExtType>>}
    */
   async installViaNpm ({ext, pkgName, pkgVer}) {
     const npmSpec = `${pkgName}${pkgVer ? '@' + pkgVer : ''}`;
@@ -261,33 +268,25 @@ export default class ExtensionCommand {
     const msg = `Installing '${ext}'${specMsg}`;
     try {
       const pkgJsonData = await spinWith(this.isJsonOutput, msg, async () => (
-        await this.npm.installPackage({
-          pkgDir: path.resolve(this.config.appiumHome, pkgName),
-          pkgName,
+        await npm.installPackage(this.config.appiumHome, pkgName, {
           pkgVer
         })
       ));
-      const extData = this.getExtensionFields(pkgJsonData);
-      extData.installPath = pkgName;
-      return extData;
+      return this.getExtensionFields(pkgJsonData);
     } catch (err) {
       throw new Error(`Encountered an error when installing package: ${err.message}`);
     }
   }
 
-  /**
-   * @typedef {Object} ExtensionArgs
-   * @property {string} extName - the name of an extension
-   * @property {object} extData - the data for an installed extension
-   */
-
   /**
    * Get the text which should be displayed to the user after an extension has been installed. This
    * is designed to be overridden by drivers/plugins with their own particular text.
    *
    * @param {ExtensionArgs} args
+   * @returns {string}
    */
-  getPostInstallText (/*{extName, extData}*/) {
+  // eslint-disable-next-line no-unused-vars
+  getPostInstallText (args) {
     throw new Error('Must be implemented in final class');
   }
 
@@ -316,30 +315,25 @@ export default class ExtensionCommand {
    * presence and form of those fields on the package.json data, throwing an error if anything is
    * amiss.
    *
-   * @param {object} appiumPkgData - the data in the "appium" field of package.json for an
-   * extension
+   * @param {import('../extension/manifest').ExternalData<ExtType>} appiumPkgData - the data in the "appium" field of package.json for an extension
    */
-  validateExtensionFields (/*appiumPkgData*/) {
+  // eslint-disable-next-line no-unused-vars
+  validateExtensionFields (appiumPkgData) {
     throw new Error('Must be implemented in final class');
   }
-
-  /**
-   * @typedef {Object} UninstallArgs
-   * @property {string} ext - the name or spec of an extension to uninstall
-   */
-
   /**
    * Uninstall an extension
    *
-   * @param {UninstallArgs} args
-   * @return {object} map of all installed extension names to extension data
+   * @param {UninstallOpts} opts
+   * @return {Promise<ExtRecord<ExtType>>} map of all installed extension names to extension data
    */
   async uninstall ({ext}) {
     if (!this.config.isInstalled(ext)) {
       throw new Error(`Can't uninstall ${this.type} '${ext}'; it is not installed`);
     }
+    const installPath = this.config.getInstallPath(ext);
     try {
-      await fs.rimraf(this.config.getInstallPath(ext));
+      await fs.rimraf(installPath);
     } finally {
       await this.config.removeExtension(ext);
     }
@@ -347,30 +341,11 @@ export default class ExtensionCommand {
     return this.config.installedExtensions;
   }
 
-  /**
-   * @typedef {Object} ExtensionUpdateOpts
-   * @property {string} ext - the name of the extension to update
-   * @property {boolean} unsafe - if true, will perform unsafe updates past major revision
-   * boundaries
-   */
-
-  /**
-   * @typedef {Object} UpdateReport
-   * @property {string} from - version updated from
-   * @property {string} to - version updated to
-   */
-
-  /**
-   * @typedef {Object} ExtensionUpdateResult
-   * @property {Object} errors - map of ext names to error objects
-   * @property {Object} updates - map of ext names to {@link UpdateReport}s
-   */
-
   /**
    * Attempt to update one or more drivers using NPM
    *
    * @param {ExtensionUpdateOpts} updateSpec
-   * @return {ExtensionUpdateResult}
+   * @return {Promise<ExtensionUpdateResult>}
    */
   async update ({ext, unsafe}) {
     const shouldUpdateAll = ext === UPDATE_ALL;
@@ -381,10 +356,12 @@ export default class ExtensionCommand {
     const extsToUpdate = shouldUpdateAll ? Object.keys(this.config.installedExtensions) : [ext];
 
     // 'errors' will have ext names as keys and error objects as values
+    /** @type {Record<string,Error>} */
     const errors = {};
 
     // 'updates' will have ext names as keys and update objects as values, where an update
     // object is of the form {from: versionString, to: versionString}
+    /** @type {Record<string,UpdateReport>} */
     const updates = {};
 
     for (const e of extsToUpdate) {
@@ -437,27 +414,20 @@ export default class ExtensionCommand {
     return {updates, errors};
   }
 
-  /**
-   * @typedef PossibleUpdates
-   * @property {string} current - current version
-   * @property {string|null} safeUpdate - version we can safely update to if it exists, or null
-   * @property {string|null} unsafeUpdate - version we can unsafely update to if it exists, or null
-   */
-
   /**
    * Given an extension name, figure out what its highest possible version upgrade is, and also the
    * highest possible safe upgrade.
    *
    * @param {string} ext - name of extension
-   * @return {PossibleUpdates}
+   * @return {Promise<PossibleUpdates>}
    */
   async checkForExtensionUpdate (ext) {
     // TODO decide how we want to handle beta versions?
     // this is a helper method, 'ext' is assumed to already be installed here, and of the npm
     // install type
     const {version, pkgName} = this.config.installedExtensions[ext];
-    let unsafeUpdate = await this.npm.getLatestVersion(pkgName);
-    let safeUpdate = await this.npm.getLatestSafeUpgradeVersion(pkgName, version);
+    let unsafeUpdate = await npm.getLatestVersion(this.config.appiumHome, pkgName);
+    let safeUpdate = await npm.getLatestSafeUpgradeVersion(this.config.appiumHome, pkgName, version);
     if (!util.compareVersions(unsafeUpdate, '>', version)) {
       // the latest version is not greater than the current version, so there's no possible update
       unsafeUpdate = null;
@@ -485,7 +455,7 @@ export default class ExtensionCommand {
     const {pkgName} = this.config.installedExtensions[ext];
     await fs.rimraf(this.config.getInstallPath(ext));
     const extData = await this.installViaNpm({ext, pkgName, pkgVer: version});
-    delete extData[`${this.type}Name`];
+    delete extData[/** @type {string} */(`${this.type}Name`)];
     await this.config.updateExtension(ext, extData);
   }
 
@@ -497,9 +467,8 @@ export default class ExtensionCommand {
    * "scripts" field is not a plain object, or if the scriptName is
    * not found within "scripts" object.
    *
-   * @param {string} ext - name of the extension to run a script from
-   * @param {string} scriptName - name of the script to run
-   * @return {RunOutput}
+   * @param {RunOptions} opts
+   * @return {Promise<RunOutput>}
    */
   async run ({ext, scriptName}) {
     if (!_.has(this.config.installedExtensions, ext)) {
@@ -508,7 +477,8 @@ export default class ExtensionCommand {
 
     const extConfig = this.config.installedExtensions[ext];
 
-    if (!_.has(extConfig, 'scripts')) {
+    // note: TS cannot understand that _.has() is a type guard
+    if (!extConfig.scripts) {
       throw new Error(`The ${this.type} named '${ext}' does not contain the ` +
                       `"scripts" field underneath the "appium" field in its package.json`);
     }
@@ -523,8 +493,10 @@ export default class ExtensionCommand {
       throw new Error(`The ${this.type} named '${ext}' does not support the script: '${scriptName}'`);
     }
 
-    const runner = new SubProcess(process.execPath, [extScripts[scriptName]], {
-      cwd: this.config.getExtensionRequirePath(ext)
+    const runner = new SubProcess(process.execPath, [
+      extScripts[scriptName]
+    ], {
+      cwd: this.config.getInstallPath(ext)
     });
 
     const output = new RingBuffer(50);
@@ -548,7 +520,116 @@ export default class ExtensionCommand {
 }
 
 /**
- * @typedef {Object} RunOutput
- * @property {string|undefined} error - error message if script ran unsuccessfully, otherwise undefined
+ * @template {ExtensionType} ExtType
+ * @typedef {import('../extension/extension-config').ExtensionConfig<ExtType>} ExtensionConfig
+ */
+
+/**
+ * Options for the {@linkcode ExtensionCommand} constructor
+ * @template {ExtensionType} ExtType
+ * @typedef ExtensionCommandOptions
+ * @property {ExtensionConfig<ExtType>} config - the `DriverConfig` or `PluginConfig` instance used for this command
+ * @property {boolean} json - whether the output of this command should be JSON or text
+ */
+
+/**
+ * Extra stuff about extensions; used indirectly by {@linkcode ExtensionCommand.list}.
+ *
+ * @typedef ExtensionMetadata
+ * @property {boolean} installed - If `true`, the extension is installed
+ * @property {string|null} [updateVersion] - If the extension is installed, the version it can be updated to
+ * @property {string|null} [unsafeUpdateVersion] - Same as above, but a major version bump
+ * @property {boolean} [upToDate] - If the extension is installed and the latest
+ */
+
+/**
+ * @typedef {import('../extension/manifest').ExtensionType} ExtensionType
+ */
+
+/**
+ * @template {ExtensionType} ExtType
+ * @typedef {import('../extension/manifest').ExtRecord<ExtType>} ExtRecord
+ */
+
+/**
+ * @template {ExtensionType} ExtType
+ * @typedef {import('../extension/manifest').ExtData<ExtType>} ExtData
+ */
+
+/**
+ * Return value of {@linkcode ExtensionCommand.list}.
+ * @typedef {Record<string, (import('../extension/manifest').InternalData & ExtensionMetadata) | { pkgName: string, installed: false }>} ExtensionListData
+ */
+
+/**
+ * Options for {@linkcode ExtensionCommand.run}.
+ * @typedef RunOptions
+ * @property {string} ext - name of the extension to run a script from
+ * @property {string} scriptName - name of the script to run
+ */
+
+/**
+ * Return value of {@linkcode ExtensionCommand.run}
+ *
+ * @typedef RunOutput
+ * @property {string} [error] - error message if script ran unsuccessfully, otherwise undefined
  * @property {string[]} output - script output
  */
+
+/**
+ * Options for {@linkcode ExtensionCommand.update}.
+ * @typedef ExtensionUpdateOpts
+ * @property {string} ext - the name of the extension to update
+ * @property {boolean} unsafe - if true, will perform unsafe updates past major revision boundaries
+ */
+
+/**
+ * Return value of {@linkcode ExtensionCommand.update}.
+ * @typedef ExtensionUpdateResult
+ * @property {Record<string,Error>} errors - map of ext names to error objects
+ * @property {Record<string,UpdateReport>} updates - map of ext names to {@linkcode UpdateReport}s
+ */
+
+/**
+ * Part of result of {@linkcode ExtensionCommand.update}.
+ * @typedef UpdateReport
+ * @property {string} from - version the extension was updated from
+ * @property {string} to - version the extension was updated to
+ */
+
+/**
+ * Options for {@linkcode ExtensionCommand.uninstall}.
+ * @typedef UninstallOpts
+ * @property {string} ext - the name or spec of an extension to uninstall
+ */
+
+/**
+ * Used by {@linkcode ExtensionCommand.getPostInstallText}
+ * @typedef ExtensionArgs
+ * @property {string} extName - the name of an extension
+ * @property {object} extData - the data for an installed extension
+ */
+
+/**
+ * Options for {@linkcode ExtensionCommand.installViaNpm}
+ * @typedef InstallViaNpmArgs
+ * @property {string} ext - the name or spec of an extension to install
+ * @property {string} pkgName - the NPM package name of the extension
+ * @property {string} [pkgVer] - the specific version of the NPM package
+ */
+
+/**
+ * Object returned by {@linkcode ExtensionCommand.checkForExtensionUpdate}
+ * @typedef PossibleUpdates
+ * @property {string} current - current version
+ * @property {string?} safeUpdate - version we can safely update to if it exists, or null
+ * @property {string?} unsafeUpdate - version we can unsafely update to if it exists, or null
+ */
+
+/**
+ * Options for {@linkcode ExtensionCommand.install}
+ * @typedef InstallArgs
+ * @property {string} ext - the name or spec of an extension to install
+ * @property {import('../extension/extension-config').InstallType} installType - how to install this extension. One of the INSTALL_TYPES
+ * @property {string} [packageName] - for git/github installs, the extension node package name
+ */

package/lib/cli/extension.js

@@ -2,11 +2,8 @@
 
 import DriverCommand from './driver-command';
 import PluginCommand from './plugin-command';
-import DriverConfig from '../driver-config';
-import PluginConfig from '../plugin-config';
-import { DRIVER_TYPE } from '../extension-config';
+import { DRIVER_TYPE } from '../constants';
 import { errAndQuit, log, JSON_SPACES } from './utils';
-import { APPIUM_HOME } from './args';
 
 /**
  * Run a subcommand of the 'appium driver' type. Each subcommand has its own set of arguments which
@@ -14,13 +11,14 @@ import { APPIUM_HOME } from './args';
  *
  * @param {Object} args - JS object where the key is the parameter name (as defined in
  * driver-parser.js)
- * @param {import('../ext-config-io').ExtensionType} type - Extension type
- * @oaram {ExtensionConfig} [configObject] - Extension config object, if we have one
+ * @template {ExtensionType} ExtType
+ * @param {import('../extension/extension-config').ExtensionConfig<ExtType>} configObject - Extension config object
  */
-async function runExtensionCommand (args, type, configObject) {
+async function runExtensionCommand (args, configObject) {
   // TODO driver config file should be locked while any of these commands are
   // running to prevent weird situations
   let jsonResult = null;
+  const {extensionType: type} = configObject;
   const extCmd = args[`${type}Command`];
   if (!extCmd) {
     throw new TypeError(`Cannot call ${type} command without a subcommand like 'install'`);
@@ -30,17 +28,11 @@ async function runExtensionCommand (args, type, configObject) {
     json = true;
   }
   const logFn = (msg) => log(json, msg);
-  let config;
-  if (configObject) {
-    config = configObject;
-    config.log = logFn;
-  } else {
-    config = (type === DRIVER_TYPE ? DriverConfig : PluginConfig).getInstance(APPIUM_HOME, logFn);
-  }
+  let config = configObject;
+  config.log = logFn;
   const CommandClass = type === DRIVER_TYPE ? DriverCommand : PluginCommand;
   const cmd = new CommandClass({config, json});
   try {
-    await config.read();
     jsonResult = await cmd.execute(args);
   } catch (err) {
     // in the suppress output case, we are calling this function internally and should

package/lib/cli/parser.js

@@ -2,21 +2,16 @@
 
 import { fs } from '@appium/support';
 import { ArgumentParser } from 'argparse';
-import B from 'bluebird';
 import _ from 'lodash';
 import path from 'path';
-import { DRIVER_TYPE, PLUGIN_TYPE } from '../extension-config';
+import { DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND } from '../constants';
 import { finalizeSchema, getArgSpec, hasArgSpec } from '../schema';
-import { rootDir } from '../utils';
+import { rootDir } from '../config';
 import {
-  driverConfig,
   getExtensionArgs,
-  getServerArgs,
-  pluginConfig
+  getServerArgs
 } from './args';
 
-export const SERVER_SUBCOMMAND = 'server';
-
 /**
  * If the parsed args do not contain any of these values, then we
  * will automatially inject the `server` subcommand.
@@ -258,19 +253,16 @@ class ArgParser {
 }
 
 /**
- * Creates a {@link ArgParser} instance.  Necessarily reads extension configuration
- * beforehand, and finalizes the config schema.
+ * Creates a {@link ArgParser} instance; finalizes the config schema.
  *
  * @constructs ArgParser
  * @param {boolean} [debug] - If `true`, throw instead of exit upon parsing error
- * @returns {Promise<ArgParser>}
+ * @returns {ArgParser}
  */
-async function getParser (debug = false) {
-  await B.all([driverConfig.read(), pluginConfig.read()]);
+function getParser (debug) {
   finalizeSchema();
 
   return new ArgParser(debug);
 }
 
-export default getParser;
 export { getParser, ArgParser };

package/lib/cli/plugin-command.js

@@ -1,7 +1,6 @@
 import _ from 'lodash';
 import ExtensionCommand from './extension-command';
-import { PLUGIN_TYPE } from '../extension-config';
-import { KNOWN_PLUGINS } from '../plugins';
+import { PLUGIN_TYPE, KNOWN_PLUGINS } from '../constants';
 
 const REQ_PLUGIN_FIELDS = ['pluginName', 'mainClass'];