appium 2.0.0-beta.9 → 2.0.0-rc.2

package/build/lib/cli/extension-command.js

@@ -1,404 +1,820 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-require("source-map-support/register");
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-var _npm = _interopRequireDefault(require("./npm"));
-
-var _path = _interopRequireDefault(require("path"));
-
-var _appiumSupport = require("appium-support");
-
-var _utils = require("./utils");
-
-var _extensionConfig = require("../extension-config");
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionCommand = void 0;
+/* eslint-disable no-console */
+const bluebird_1 = __importDefault(require("bluebird"));
+const lodash_1 = __importDefault(require("lodash"));
+const path_1 = __importDefault(require("path"));
+const support_1 = require("@appium/support");
+const utils_1 = require("./utils");
+const extension_config_1 = require("../extension/extension-config");
+const teen_process_1 = require("teen_process");
+const package_changed_1 = require("../extension/package-changed");
+const child_process_1 = require("child_process");
+const node_util_1 = require("node:util");
 const UPDATE_ALL = 'installed';
-
-class NotUpdatableError extends Error {}
-
-class NoUpdatesAvailableError extends Error {}
-
-class ExtensionCommand {
-  constructor({
-    config,
-    json,
-    type
-  }) {
-    this.config = config;
-    this.type = type;
-    this.isJsonOutput = json;
-    this.npm = new _npm.default(this.config.appiumHome);
-    this.knownExtensions = {};
-  }
-
-  async execute(args) {
-    const cmd = args[`${this.type}Command`];
-
-    if (!_lodash.default.isFunction(ExtensionCommand.prototype[cmd])) {
-      throw new Error(`Cannot handle ${this.type} command ${cmd}`);
-    }
-
-    const executeCmd = this[cmd].bind(this);
-    return await executeCmd(args);
-  }
-
-  async list({
-    showInstalled,
-    showUpdates
-  }) {
-    const lsMsg = `Listing ${showInstalled ? 'installed' : 'available'} ${this.type}s`;
-    const installedNames = Object.keys(this.config.installedExtensions);
-    const knownNames = Object.keys(this.knownExtensions);
-    const exts = [...installedNames, ...knownNames].reduce((acc, name) => {
-      if (!acc[name]) {
-        if (installedNames.includes(name)) {
-          acc[name] = { ...this.config.installedExtensions[name],
-            installed: true
-          };
-        } else if (!showInstalled) {
-          acc[name] = {
-            pkgName: this.knownExtensions[name],
-            installed: false
-          };
-        }
-      }
-
-      return acc;
-    }, {});
-    await (0, _utils.spinWith)(this.isJsonOutput, lsMsg, async () => {
-      if (!showUpdates) {
-        return;
-      }
-
-      for (const [ext, data] of _lodash.default.toPairs(exts)) {
-        const {
-          installed,
-          installType
-        } = data;
-
-        if (!installed || installType !== _extensionConfig.INSTALL_TYPE_NPM) {
-          continue;
-        }
-
-        const updates = await this.checkForExtensionUpdate(ext);
-        data.updateVersion = updates.safeUpdate;
-        data.unsafeUpdateVersion = updates.unsafeUpdate;
-        data.upToDate = updates.safeUpdate === null && updates.unsafeUpdate === null;
-      }
-    });
-
-    if (this.isJsonOutput) {
-      return exts;
+class NotUpdatableError extends Error {
+}
+class NoUpdatesAvailableError extends Error {
+}
+/**
+ * Omits `driverName`/`pluginName` props from the receipt to make a {@linkcode ExtManifest}
+ * @template {ExtensionType} ExtType
+ * @param {ExtInstallReceipt<ExtType>} receipt
+ * @returns {ExtManifest<ExtType>}
+ */
+function receiptToManifest(receipt) {
+    return /** @type {ExtManifest<ExtType>} */ (lodash_1.default.omit(receipt, 'driverName', 'pluginName'));
+}
+/**
+ * @template {ExtensionType} ExtType
+ */
+class ExtensionCliCommand {
+    /**
+     * Build an ExtensionCommand
+     * @param {ExtensionCommandOptions<ExtType>} opts
+     */
+    constructor({ config, json }) {
+        this.config = config;
+        this.log = new support_1.console.CliConsole({ jsonMode: json });
+        this.isJsonOutput = Boolean(json);
     }
-
-    for (const [name, {
-      installType,
-      installSpec,
-      installed,
-      updateVersion,
-      unsafeUpdateVersion,
-      version,
-      upToDate
-    }] of _lodash.default.toPairs(exts)) {
-      let typeTxt;
-
-      switch (installType) {
-        case _extensionConfig.INSTALL_TYPE_GIT:
-        case _extensionConfig.INSTALL_TYPE_GITHUB:
-          typeTxt = `(cloned from ${installSpec})`.yellow;
-          break;
-
-        case _extensionConfig.INSTALL_TYPE_LOCAL:
-          typeTxt = `(linked from ${installSpec})`.magenta;
-          break;
-
-        default:
-          typeTxt = '(NPM)';
-      }
-
-      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}`);
+    /**
+     * `driver` or `plugin`, depending on the `ExtensionConfig`.
+     */
+    get type() {
+        return this.config.extensionType;
     }
-
-    return exts;
-  }
-
-  async install({
-    ext,
-    installType,
-    packageName
-  }) {
-    (0, _utils.log)(this.isJsonOutput, `Attempting to find and install ${this.type} '${ext}'`);
-    let extData;
-    let installSpec = ext;
-
-    if (packageName && [_extensionConfig.INSTALL_TYPE_LOCAL, _extensionConfig.INSTALL_TYPE_NPM].includes(installType)) {
-      throw new Error(`When using --source=${installType}, cannot also use --package`);
+    /**
+     * Logs a message and returns an {@linkcode Error} to throw.
+     *
+     * For TS to understand that a function throws an exception, it must actually throw an exception--
+     * in other words, _calling_ a function which is guaranteed to throw an exception is not enough--
+     * nor is something like `@returns {never}` which does not imply a thrown exception.
+     * @param {string} message
+     * @protected
+     * @throws {Error}
+     */
+    _createFatalError(message) {
+        return new Error(this.log.decorate(message, 'error'));
     }
-
-    if (!packageName && [_extensionConfig.INSTALL_TYPE_GIT, _extensionConfig.INSTALL_TYPE_GITHUB].includes(installType)) {
-      throw new Error(`When using --source=${installType}, must also use --package`);
+    /**
+     * 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 {Promise<object>} the result of the specific command which is executed
+     */
+    async execute(args) {
+        const cmd = args[`${this.type}Command`];
+        if (!lodash_1.default.isFunction(this[cmd])) {
+            throw this._createFatalError(`Cannot handle ${this.type} command ${cmd}`);
+        }
+        const executeCmd = this[cmd].bind(this);
+        return await executeCmd(args);
     }
-
-    if (installType === _extensionConfig.INSTALL_TYPE_LOCAL) {
-      const msg = `Linking ${this.type} from local path`;
-      const pkgJsonData = await (0, _utils.spinWith)(this.isJsonOutput, msg, async () => await this.npm.linkPackage(installSpec));
-      extData = this.getExtensionFields(pkgJsonData);
-      extData.installPath = extData.pkgName;
-    } else if (installType === _extensionConfig.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
-      });
-    } else if (installType === _extensionConfig.INSTALL_TYPE_GIT) {
-      installSpec = installSpec.replace(/\.git$/, '');
-      extData = await this.installViaNpm({
-        ext: installSpec,
-        pkgName: packageName
-      });
-    } else {
-      let name, pkgVer;
-      const splits = installSpec.split('@');
-
-      if (installSpec[0] === '@') {
-        [name, pkgVer] = [`@${splits[1]}`, splits[2]];
-      } else {
-        [name, pkgVer] = splits;
-      }
-
-      let pkgName;
-
-      if (installType === _extensionConfig.INSTALL_TYPE_NPM) {
-        pkgName = name;
-      } else {
+    /**
+     * List extensions
+     * @template {ExtensionType} ExtType
+     * @param {ListOptions} opts
+     * @return {Promise<ExtensionList<ExtType>>} map of extension names to extension data
+     */
+    async list({ showInstalled, showUpdates, verbose = false }) {
+        let lsMsg = `Listing ${showInstalled ? 'installed' : 'available'} ${this.type}s`;
+        if (verbose) {
+            lsMsg += ' (verbose mode)';
+        }
+        const installedNames = Object.keys(this.config.installedExtensions);
         const knownNames = Object.keys(this.knownExtensions);
-
-        if (!_lodash.default.includes(knownNames, name)) {
-          const msg = `Could not resolve ${this.type}; are you sure it's in the list ` + `of supported ${this.type}s? ${JSON.stringify(knownNames)}`;
-          throw new Error(msg);
-        }
-
-        pkgName = this.knownExtensions[name];
-        installType = _extensionConfig.INSTALL_TYPE_NPM;
-      }
-
-      extData = await this.installViaNpm({
-        ext,
-        pkgName,
-        pkgVer
-      });
+        const listData = [...installedNames, ...knownNames].reduce((acc, name) => {
+            if (!acc[name]) {
+                if (installedNames.includes(name)) {
+                    acc[name] = {
+                        ... /** @type {Partial<ExtManifest<ExtType>>} */(this.config.installedExtensions[name]),
+                        installed: true,
+                    };
+                }
+                else if (!showInstalled) {
+                    acc[name] = /** @type {ExtensionListData<ExtType>} */ ({
+                        pkgName: this.knownExtensions[name],
+                        installed: false,
+                    });
+                }
+            }
+            return acc;
+        }, /** @type {ExtensionList<ExtType>} */ ({}));
+        // if we want to show whether updates are available, put that behind a spinner
+        await (0, utils_1.spinWith)(this.isJsonOutput, lsMsg, async () => {
+            if (!showUpdates) {
+                return;
+            }
+            for (const [ext, data] of lodash_1.default.toPairs(listData)) {
+                if (!data.installed || data.installType !== extension_config_1.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;
+                }
+                try {
+                    const updates = await this.checkForExtensionUpdate(ext);
+                    data.updateVersion = updates.safeUpdate;
+                    data.unsafeUpdateVersion = updates.unsafeUpdate;
+                    data.upToDate = updates.safeUpdate === null && updates.unsafeUpdate === null;
+                }
+                catch (e) {
+                    data.updateError = e.message;
+                }
+            }
+        });
+        /**
+         * Type guard to narrow "installed" extensions, which have more data
+         * @param {any} data
+         * @returns {data is InstalledExtensionListData<ExtType>}
+         */
+        const extIsInstalled = (data) => Boolean(data.installed);
+        // if we're just getting the data, short circuit return here since we don't need to do any
+        // formatting logic
+        if (this.isJsonOutput) {
+            return listData;
+        }
+        if (verbose) {
+            this.log.log((0, node_util_1.inspect)(listData, { colors: true, depth: null }));
+            return listData;
+        }
+        for (const [name, data] of lodash_1.default.toPairs(listData)) {
+            let installTxt = ' [not installed]'.grey;
+            let updateTxt = '';
+            let upToDateTxt = '';
+            let unsafeUpdateTxt = '';
+            if (extIsInstalled(data)) {
+                const { installType, installSpec, updateVersion, unsafeUpdateVersion, version, upToDate, updateError, } = data;
+                let typeTxt;
+                switch (installType) {
+                    case extension_config_1.INSTALL_TYPE_GIT:
+                    case extension_config_1.INSTALL_TYPE_GITHUB:
+                        typeTxt = `(cloned from ${installSpec})`.yellow;
+                        break;
+                    case extension_config_1.INSTALL_TYPE_LOCAL:
+                        typeTxt = `(linked from ${installSpec})`.magenta;
+                        break;
+                    case extension_config_1.INSTALL_TYPE_DEV:
+                        typeTxt = '(dev mode)';
+                        break;
+                    default:
+                        typeTxt = '(npm)';
+                }
+                installTxt = `@${version.yellow} ${('[installed ' + typeTxt + ']').green}`;
+                if (showUpdates) {
+                    if (updateError) {
+                        updateTxt = ` [Cannot check for updates: ${updateError}]`.red;
+                    }
+                    else {
+                        if (updateVersion) {
+                            updateTxt = ` [${updateVersion} available]`.magenta;
+                        }
+                        if (upToDate) {
+                            upToDateTxt = ` [Up to date]`.green;
+                        }
+                        if (unsafeUpdateVersion) {
+                            unsafeUpdateTxt = ` [${unsafeUpdateVersion} available (potentially unsafe)]`.cyan;
+                        }
+                    }
+                }
+            }
+            this.log.log(`- ${name.yellow}${installTxt}${updateTxt}${upToDateTxt}${unsafeUpdateTxt}`);
+        }
+        return listData;
     }
-
-    const extName = extData[`${this.type}Name`];
-    delete extData[`${this.type}Name`];
-
-    if (this.config.isInstalled(extName)) {
-      throw new Error(`A ${this.type} named '${extName}' is already installed. ` + `Did you mean to update? 'appium ${this.type} update'. See ` + `installed ${this.type}s with 'appium ${this.type} list --installed'.`);
+    /**
+     * Install an extension
+     *
+     * @param {InstallOpts} opts
+     * @return {Promise<ExtRecord<ExtType>>} map of all installed extension names to extension data
+     */
+    async _install({ installSpec, installType, packageName }) {
+        /** @type {ExtInstallReceipt<ExtType>} */
+        let receipt;
+        if (packageName && [extension_config_1.INSTALL_TYPE_LOCAL, extension_config_1.INSTALL_TYPE_NPM].includes(installType)) {
+            throw this._createFatalError(`When using --source=${installType}, cannot also use --package`);
+        }
+        if (!packageName && [extension_config_1.INSTALL_TYPE_GIT, extension_config_1.INSTALL_TYPE_GITHUB].includes(installType)) {
+            throw this._createFatalError(`When using --source=${installType}, must also use --package`);
+        }
+        /**
+         * @type {InstallViaNpmArgs}
+         */
+        let installViaNpmOpts;
+        /**
+         * The probable (?) name of the extension derived from the install spec.
+         *
+         * If using a local install type, this will remain empty.
+         * @type {string}
+         */
+        let probableExtName = '';
+        // depending on `installType`, build the options to pass into `installViaNpm`
+        if (installType === extension_config_1.INSTALL_TYPE_GITHUB) {
+            if (installSpec.split('/').length !== 2) {
+                throw this._createFatalError(`Github ${this.type} spec ${installSpec} appeared to be invalid; ` +
+                    'it should be of the form <org>/<repo>');
+            }
+            installViaNpmOpts = {
+                installSpec,
+                installType,
+                pkgName: /** @type {string} */ (packageName),
+            };
+            probableExtName = installSpec;
+        }
+        else if (installType === extension_config_1.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$/, '');
+            installViaNpmOpts = {
+                installSpec,
+                installType,
+                pkgName: /** @type {string} */ (packageName),
+            };
+            probableExtName = installSpec;
+        }
+        else {
+            let pkgName, pkgVer;
+            if (installType === extension_config_1.INSTALL_TYPE_LOCAL) {
+                pkgName = path_1.default.isAbsolute(installSpec) ? installSpec : path_1.default.resolve(installSpec);
+            }
+            else {
+                // at this point we have either an npm package or an appium verified extension
+                // name or a local path. both of which will be installed via npm.
+                // extensions installed via npm can include versions or tags after the '@'
+                // sign, so check for that. We also need to be careful that package names themselves can
+                // contain the '@' symbol, as in `npm install @appium/fake-driver@1.2.0`
+                let name;
+                const splits = installSpec.split('@');
+                if (installSpec[0] === '@') {
+                    // this is the case where we have an npm org included in the package name
+                    [name, pkgVer] = [`@${splits[1]}`, splits[2]];
+                }
+                else {
+                    // this is the case without an npm org
+                    [name, pkgVer] = splits;
+                }
+                if (installType === extension_config_1.INSTALL_TYPE_NPM) {
+                    // if we're installing a named package from npm, we don't need to check
+                    // against the appium extension list; just use the installSpec as is
+                    pkgName = name;
+                }
+                else {
+                    // if we're installing a named appium driver (like 'xcuitest') we need to
+                    // dereference the actual npm package ('appiupm-xcuitest-driver'), so
+                    // check it exists and get the correct package
+                    const knownNames = Object.keys(this.knownExtensions);
+                    if (!lodash_1.default.includes(knownNames, name)) {
+                        const msg = `Could not resolve ${this.type}; are you sure it's in the list ` +
+                            `of supported ${this.type}s? ${JSON.stringify(knownNames)}`;
+                        throw this._createFatalError(msg);
+                    }
+                    probableExtName = name;
+                    pkgName = this.knownExtensions[name];
+                    // given that we'll use the install type in the driver json, store it as
+                    // 'npm' now
+                    installType = extension_config_1.INSTALL_TYPE_NPM;
+                }
+            }
+            installViaNpmOpts = { installSpec, pkgName, pkgVer, installType };
+        }
+        // fail fast here if we can
+        if (probableExtName && this.config.isInstalled(probableExtName)) {
+            throw this._createFatalError(`A ${this.type} named "${probableExtName}" is already installed. ` +
+                `Did you mean to update? Run "appium ${this.type} update". See ` +
+                `installed ${this.type}s with "appium ${this.type} list --installed".`);
+        }
+        receipt = await this.installViaNpm(installViaNpmOpts);
+        // this _should_ be the same as `probablyExtName` as the one derived above unless
+        // install type is local.
+        /** @type {string} */
+        const extName = receipt[ /** @type {string} */(`${this.type}Name`)];
+        // check _a second time_ with the more-accurate extName
+        if (this.config.isInstalled(extName)) {
+            throw this._createFatalError(`A ${this.type} named "${extName}" is already installed. ` +
+                `Did you mean to update? Run "appium ${this.type} update". See ` +
+                `installed ${this.type}s with "appium ${this.type} list --installed".`);
+        }
+        // this field does not exist as such in the manifest (it's used as a property name instead)
+        // so that's why it's being removed here.
+        /** @type {ExtManifest<ExtType>} */
+        const extManifest = receiptToManifest(receipt);
+        const [errors, warnings] = await bluebird_1.default.all([
+            this.config.getProblems(extName, extManifest),
+            this.config.getWarnings(extName, extManifest),
+        ]);
+        const errorMap = new Map([[extName, errors]]);
+        const warningMap = new Map([[extName, warnings]]);
+        const { errorSummaries, warningSummaries } = this.config.getValidationResultSummaries(errorMap, warningMap);
+        if (!lodash_1.default.isEmpty(errorSummaries)) {
+            throw this._createFatalError(errorSummaries.join('\n'));
+        }
+        // note that we won't show any warnings if there were errors.
+        if (!lodash_1.default.isEmpty(warningSummaries)) {
+            this.log.warn(warningSummaries.join('\n'));
+        }
+        await this.config.addExtension(extName, extManifest);
+        // update the hash if we've changed the local `package.json`
+        if (await support_1.env.hasAppiumDependency(this.config.appiumHome)) {
+            await (0, package_changed_1.packageDidChange)(this.config.appiumHome);
+        }
+        // log info for the user
+        this.log.info(this.getPostInstallText({ extName, extData: receipt }));
+        return this.config.installedExtensions;
     }
-
-    extData.installType = installType;
-    extData.installSpec = installSpec;
-    await this.config.addExtension(extName, extData);
-    (0, _utils.log)(this.isJsonOutput, this.getPostInstallText({
-      extName,
-      extData
-    }));
-    return this.config.installedExtensions;
-  }
-
-  async installViaNpm({
-    ext,
-    pkgName,
-    pkgVer
-  }) {
-    const npmSpec = `${pkgName}${pkgVer ? '@' + pkgVer : ''}`;
-    const specMsg = npmSpec === ext ? '' : ` using NPM install spec '${npmSpec}'`;
-    const msg = `Installing '${ext}'${specMsg}`;
-
-    try {
-      const pkgJsonData = await (0, _utils.spinWith)(this.isJsonOutput, msg, async () => await this.npm.installPackage({
-        pkgDir: _path.default.resolve(this.config.appiumHome, pkgName),
-        pkgName,
-        pkgVer
-      }));
-      const extData = this.getExtensionFields(pkgJsonData);
-      extData.installPath = pkgName;
-      return extData;
-    } catch (err) {
-      throw new Error(`Encountered an error when installing package: ${err.message}`);
+    /**
+     * Install an extension via NPM
+     *
+     * @param {InstallViaNpmArgs} args
+     * @returns {Promise<ExtInstallReceipt<ExtType>>}
+     */
+    async installViaNpm({ installSpec, pkgName, pkgVer, installType }) {
+        const npmSpec = `${pkgName}${pkgVer ? '@' + pkgVer : ''}`;
+        const specMsg = npmSpec === installSpec ? '' : ` using NPM install spec '${npmSpec}'`;
+        const msg = `Installing '${installSpec}'${specMsg}`;
+        try {
+            const { pkg, path } = await (0, utils_1.spinWith)(this.isJsonOutput, msg, async () => {
+                const { pkg, installPath: path } = await support_1.npm.installPackage(this.config.appiumHome, pkgName, {
+                    pkgVer,
+                    installType,
+                });
+                this.validatePackageJson(pkg, installSpec);
+                return { pkg, path };
+            });
+            return this.getInstallationReceipt({
+                pkg,
+                installPath: path,
+                installType,
+                installSpec,
+            });
+        }
+        catch (err) {
+            throw this._createFatalError(`Encountered an error when installing package: ${err.message}`);
+        }
     }
-  }
-
-  getPostInstallText() {
-    throw new Error('Must be implemented in final class');
-  }
-
-  getExtensionFields(pkgJsonData) {
-    if (!pkgJsonData.appium) {
-      throw new Error(`Installed driver did not have an 'appium' section in its ` + `package.json file as expected`);
+    /**
+     * 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}
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getPostInstallText(args) {
+        throw this._createFatalError('Must be implemented in final class');
     }
-
-    const {
-      appium,
-      name,
-      version
-    } = pkgJsonData;
-    this.validateExtensionFields(appium);
-    return { ...appium,
-      pkgName: name,
-      version
-    };
-  }
-
-  validateExtensionFields() {
-    throw new Error('Must be implemented in final class');
-  }
-
-  async uninstall({
-    ext
-  }) {
-    if (!this.config.isInstalled(ext)) {
-      throw new Error(`Can't uninstall ${this.type} '${ext}'; it is not installed`);
+    /**
+     * Once a package is installed on-disk, this gathers some necessary metadata for validation.
+     *
+     * @param {GetInstallationReceiptOpts<ExtType>} opts
+     * @returns {ExtInstallReceipt<ExtType>}
+     */
+    getInstallationReceipt({ pkg, installPath, installType, installSpec }) {
+        const { appium, name, version, peerDependencies } = pkg;
+        /** @type {import('appium/types').InternalMetadata} */
+        const internal = {
+            pkgName: name,
+            version,
+            installType,
+            installSpec,
+            installPath,
+            appiumVersion: peerDependencies?.appium,
+        };
+        /** @type {ExtMetadata<ExtType>} */
+        const extMetadata = appium;
+        return {
+            ...internal,
+            ...extMetadata,
+        };
     }
-
-    try {
-      await _appiumSupport.fs.rimraf(this.config.getInstallPath(ext));
-    } finally {
-      await this.config.removeExtension(ext);
+    /**
+     * Validates the _required_ root fields of an extension's `package.json` file.
+     *
+     * These required fields are:
+     * - `name`
+     * - `version`
+     * - `appium`
+     * @param {import('type-fest').PackageJson} pkg - `package.json` of extension
+     * @param {string} installSpec - Extension name/spec
+     * @throws {ReferenceError} If `package.json` has a missing or invalid field
+     * @returns {pkg is ExtPackageJson<ExtType>}
+     */
+    validatePackageJson(pkg, installSpec) {
+        const { appium, name, version } = /** @type {ExtPackageJson<ExtType>} */ (pkg);
+        /**
+         *
+         * @param {string} field
+         * @returns {ReferenceError}
+         */
+        const createMissingFieldError = (field) => new ReferenceError(`${this.type} "${installSpec}" invalid; missing a \`${field}\` field of its \`package.json\``);
+        if (!name) {
+            throw createMissingFieldError('name');
+        }
+        if (!version) {
+            throw createMissingFieldError('version');
+        }
+        if (!appium) {
+            throw createMissingFieldError('appium');
+        }
+        this.validateExtensionFields(appium, installSpec);
+        return true;
     }
-
-    (0, _utils.log)(this.isJsonOutput, `Successfully uninstalled ${this.type} '${ext}'`.green);
-    return this.config.installedExtensions;
-  }
-
-  async update({
-    ext,
-    unsafe
-  }) {
-    const shouldUpdateAll = ext === UPDATE_ALL;
-
-    if (!shouldUpdateAll && !this.config.isInstalled(ext)) {
-      throw new Error(`The ${this.type} '${ext}' was not installed, so can't be updated`);
+    /**
+     * For any `package.json` fields which a particular type of extension requires, validate the
+     * presence and form of those fields on the `package.json` data, throwing an error if anything is
+     * amiss.
+     *
+     * @param {ExtMetadata<ExtType>} extMetadata - the data in the "appium" field of `package.json` for an extension
+     * @param {string} installSpec - Extension name/spec
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    validateExtensionFields(extMetadata, installSpec) {
+        throw this._createFatalError('Must be implemented in final class');
     }
-
-    const extsToUpdate = shouldUpdateAll ? Object.keys(this.config.installedExtensions) : [ext];
-    const errors = {};
-    const updates = {};
-
-    for (const e of extsToUpdate) {
-      try {
-        await (0, _utils.spinWith)(this.isJsonOutput, `Checking if ${this.type} '${e}' is updatable`, () => {
-          if (this.config.installedExtensions[e].installType !== _extensionConfig.INSTALL_TYPE_NPM) {
-            throw new NotUpdatableError();
-          }
-        });
-        const update = await (0, _utils.spinWith)(this.isJsonOutput, `Checking if ${this.type} '${e}' needs an update`, async () => {
-          const update = await this.checkForExtensionUpdate(e);
-
-          if (!(update.safeUpdate || update.unsafeUpdate)) {
-            throw new NoUpdatesAvailableError();
-          }
-
-          return update;
-        });
-
-        if (!unsafe && !update.safeUpdate) {
-          throw new Error(`The ${this.type} '${e}' has a major revision update ` + `(${update.current} => ${update.unsafeUpdate}), which could include ` + `breaking changes. If you want to apply this update, re-run with --unsafe`);
-        }
-
-        const updateVer = unsafe && update.unsafeUpdate ? update.unsafeUpdate : update.safeUpdate;
-        await (0, _utils.spinWith)(this.isJsonOutput, `Updating driver '${e}' from ${update.current} to ${updateVer}`, async () => await this.updateExtension(e, updateVer));
-        updates[e] = {
-          from: update.current,
-          to: updateVer
-        };
-      } catch (err) {
-        errors[e] = err;
-      }
+    /**
+     * Uninstall an extension.
+     *
+     * First tries to do this via `npm uninstall`, but if that fails, just `rm -rf`'s the extension dir.
+     *
+     * Will only remove the extension from the manifest if it has been successfully removed.
+     *
+     * @param {UninstallOpts} opts
+     * @return {Promise<ExtRecord<ExtType>>} map of all installed extension names to extension data (without the extension just uninstalled)
+     */
+    async _uninstall({ installSpec }) {
+        if (!this.config.isInstalled(installSpec)) {
+            throw this._createFatalError(`Can't uninstall ${this.type} '${installSpec}'; it is not installed`);
+        }
+        const extRecord = this.config.installedExtensions[installSpec];
+        if (extRecord.installType === extension_config_1.INSTALL_TYPE_DEV) {
+            this.log.warn(`Cannot uninstall ${this.type} "${installSpec}" because it is in development!`);
+            return this.config.installedExtensions;
+        }
+        const pkgName = extRecord.pkgName;
+        await support_1.npm.uninstallPackage(this.config.appiumHome, pkgName);
+        await this.config.removeExtension(installSpec);
+        this.log.ok(`Successfully uninstalled ${this.type} '${installSpec}'`.green);
+        return this.config.installedExtensions;
     }
-
-    (0, _utils.log)(this.isJsonOutput, 'Update report:');
-
-    for (const [e, update] of _lodash.default.toPairs(updates)) {
-      (0, _utils.log)(this.isJsonOutput, `- ${this.type} ${e} updated: ${update.from} => ${update.to}`.green);
+    /**
+     * Attempt to update one or more drivers using NPM
+     *
+     * @param {ExtensionUpdateOpts} updateSpec
+     * @return {Promise<ExtensionUpdateResult>}
+     */
+    async _update({ installSpec, unsafe }) {
+        const shouldUpdateAll = installSpec === UPDATE_ALL;
+        // if we're specifically requesting an update for an extension, make sure it's installed
+        if (!shouldUpdateAll && !this.config.isInstalled(installSpec)) {
+            throw this._createFatalError(`The ${this.type} "${installSpec}" was not installed, so can't be updated`);
+        }
+        const extsToUpdate = shouldUpdateAll
+            ? Object.keys(this.config.installedExtensions)
+            : [installSpec];
+        // '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) {
+            try {
+                await (0, utils_1.spinWith)(this.isJsonOutput, `Checking if ${this.type} '${e}' is updatable`, () => {
+                    if (this.config.installedExtensions[e].installType !== extension_config_1.INSTALL_TYPE_NPM) {
+                        throw new NotUpdatableError();
+                    }
+                });
+                const update = await (0, utils_1.spinWith)(this.isJsonOutput, `Checking if ${this.type} '${e}' needs an update`, async () => {
+                    const update = await this.checkForExtensionUpdate(e);
+                    if (!(update.safeUpdate || update.unsafeUpdate)) {
+                        throw new NoUpdatesAvailableError();
+                    }
+                    return update;
+                });
+                if (!unsafe && !update.safeUpdate) {
+                    throw this._createFatalError(`The ${this.type} '${e}' has a major revision update ` +
+                        `(${update.current} => ${update.unsafeUpdate}), which could include ` +
+                        `breaking changes. If you want to apply this update, re-run with --unsafe`);
+                }
+                const updateVer = unsafe && update.unsafeUpdate ? update.unsafeUpdate : update.safeUpdate;
+                await (0, utils_1.spinWith)(this.isJsonOutput, `Updating driver '${e}' from ${update.current} to ${updateVer}`, async () => await this.updateExtension(e, updateVer));
+                updates[e] = { from: update.current, to: updateVer };
+            }
+            catch (err) {
+                errors[e] = err;
+            }
+        }
+        this.log.info('Update report:');
+        for (const [e, update] of lodash_1.default.toPairs(updates)) {
+            this.log.ok(`  - ${this.type} ${e} updated: ${update.from} => ${update.to}`.green);
+        }
+        for (const [e, err] of lodash_1.default.toPairs(errors)) {
+            if (err instanceof NotUpdatableError) {
+                this.log.warn(`  - '${e}' was not installed via npm, so we could not check ` + `for updates`.yellow);
+            }
+            else if (err instanceof NoUpdatesAvailableError) {
+                this.log.info(`  - '${e}' had no updates available`.yellow);
+            }
+            else {
+                // otherwise, make it pop with red!
+                this.log.error(`  - '${e}' failed to update: ${err}`.red);
+            }
+        }
+        return { updates, errors };
     }
-
-    for (const [e, err] of _lodash.default.toPairs(errors)) {
-      if (err instanceof NotUpdatableError) {
-        (0, _utils.log)(this.isJsonOutput, `- '${e}' was not installed via npm, so we could not check ` + `for updates`.yellow);
-      } else if (err instanceof NoUpdatesAvailableError) {
-        (0, _utils.log)(this.isJsonOutput, `- '${e}' had no updates available`.yellow);
-      } else {
-        (0, _utils.log)(this.isJsonOutput, `- '${e}' failed to update: ${err}`.red);
-      }
+    /**
+     * 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 {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];
+        /** @type {string?} */
+        let unsafeUpdate = await support_1.npm.getLatestVersion(this.config.appiumHome, pkgName);
+        let safeUpdate = await support_1.npm.getLatestSafeUpgradeVersion(this.config.appiumHome, pkgName, version);
+        if (unsafeUpdate !== null && !support_1.util.compareVersions(unsafeUpdate, '>', version)) {
+            // the latest version is not greater than the current version, so there's no possible update
+            unsafeUpdate = null;
+            safeUpdate = null;
+        }
+        if (unsafeUpdate && unsafeUpdate === safeUpdate) {
+            // the latest update is the same as the safe update, which means it's not actually unsafe
+            unsafeUpdate = null;
+        }
+        if (safeUpdate && !support_1.util.compareVersions(safeUpdate, '>', version)) {
+            // even the safe update is not later than the current, so it is not actually an update
+            safeUpdate = null;
+        }
+        return { current: version, safeUpdate, unsafeUpdate };
     }
-
-    return {
-      updates,
-      errors
-    };
-  }
-
-  async checkForExtensionUpdate(ext) {
-    const {
-      version,
-      pkgName
-    } = this.config.installedExtensions[ext];
-    let unsafeUpdate = await this.npm.getLatestVersion(pkgName);
-    let safeUpdate = await this.npm.getLatestSafeUpgradeVersion(pkgName, version);
-
-    if (!_appiumSupport.util.compareVersions(unsafeUpdate, '>', version)) {
-      unsafeUpdate = null;
-      safeUpdate = null;
+    /**
+     * Actually update an extension installed by NPM, using the NPM cli. And update the installation
+     * manifest.
+     *
+     * @param {string} installSpec - name of extension to update
+     * @param {string} version - version string identifier to update extension to
+     * @returns {Promise<void>}
+     */
+    async updateExtension(installSpec, version) {
+        const { pkgName, installType } = this.config.installedExtensions[installSpec];
+        const extData = await this.installViaNpm({
+            installSpec,
+            installType,
+            pkgName,
+            pkgVer: version,
+        });
+        delete extData[ /** @type {string} */(`${this.type}Name`)];
+        await this.config.updateExtension(installSpec, extData);
     }
-
-    if (unsafeUpdate && unsafeUpdate === safeUpdate) {
-      unsafeUpdate = null;
+    /**
+     * Just wraps {@linkcode child_process.spawn} with some default options
+     *
+     * @param {string} cwd - CWD
+     * @param {string} script - Path to script
+     * @param {string[]} args - Extra args for script
+     * @param {import('child_process').SpawnOptions} opts - Options
+     * @returns {import('node:child_process').ChildProcess}
+     */
+    _runUnbuffered(cwd, script, args = [], opts = {}) {
+        return (0, child_process_1.spawn)(process.execPath, [script, ...args], {
+            cwd,
+            stdio: 'inherit',
+            ...opts,
+        });
     }
-
-    if (safeUpdate && !_appiumSupport.util.compareVersions(safeUpdate, '>', version)) {
-      safeUpdate = null;
+    /**
+     * Runs a script cached inside the `scripts` field under `appium`
+     * inside of the extension's `package.json` file. Will throw
+     * an error if the driver/plugin does not contain a `scripts` field
+     * underneath the `appium` field in its `package.json`, if the
+     * `scripts` field is not a plain object, or if the `scriptName` is
+     * not found within `scripts` object.
+     *
+     * @param {RunOptions} opts
+     * @return {Promise<RunOutput>}
+     */
+    async _run({ installSpec, scriptName, extraArgs = [], bufferOutput = false }) {
+        if (!this.config.isInstalled(installSpec)) {
+            throw this._createFatalError(`The ${this.type} "${installSpec}" is not installed`);
+        }
+        const extConfig = this.config.installedExtensions[installSpec];
+        // note: TS cannot understand that _.has() is a type guard
+        if (!('scripts' in extConfig)) {
+            throw this._createFatalError(`The ${this.type} named '${installSpec}' does not contain the ` +
+                `"scripts" field underneath the "appium" field in its package.json`);
+        }
+        const extScripts = extConfig.scripts;
+        if (!extScripts || !lodash_1.default.isPlainObject(extScripts)) {
+            throw this._createFatalError(`The ${this.type} named '${installSpec}' "scripts" field must be a plain object`);
+        }
+        if (!(scriptName in /** @type {Record<string,string>} */ (extScripts))) {
+            throw this._createFatalError(`The ${this.type} named '${installSpec}' does not support the script: '${scriptName}'`);
+        }
+        if (bufferOutput) {
+            const runner = new teen_process_1.SubProcess(process.execPath, [extScripts[scriptName], ...extraArgs], {
+                cwd: this.config.getInstallPath(installSpec),
+            });
+            const output = new utils_1.RingBuffer(50);
+            runner.on('stream-line', (line) => {
+                output.enqueue(line);
+                this.log.log(line);
+            });
+            await runner.start(0);
+            try {
+                await runner.join();
+                this.log.ok(`${scriptName} successfully ran`.green);
+                return { output: output.getBuff() };
+            }
+            catch (err) {
+                this.log.error(`Encountered an error when running '${scriptName}': ${err.message}`.red);
+                return { error: err.message, output: output.getBuff() };
+            }
+        }
+        try {
+            await new bluebird_1.default((resolve, reject) => {
+                this._runUnbuffered(this.config.getInstallPath(installSpec), extScripts[scriptName], extraArgs)
+                    .on('error', (err) => {
+                    // generally this is of the "I can't find the script" variety.
+                    // this is a developer bug: the extension is pointing to a script that is not where the
+                    // developer said it would be (in `appium.scripts` of the extension's `package.json`)
+                    reject(err);
+                })
+                    .on('close', (code) => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`Script "${scriptName}" exited with code ${code}`));
+                    }
+                });
+            });
+            this.log.ok(`${scriptName} successfully ran`.green);
+            return {};
+        }
+        catch (err) {
+            this.log.error(`Encountered an error when running '${scriptName}': ${err.message}`.red);
+            return { error: err.message };
+        }
     }
-
-    return {
-      current: version,
-      safeUpdate,
-      unsafeUpdate
-    };
-  }
-
-  async updateExtension(ext, version) {
-    const {
-      pkgName
-    } = this.config.installedExtensions[ext];
-    await this.installViaNpm({
-      ext,
-      pkgName,
-      pkgVer: version
-    });
-    this.config.installedExtensions[ext].version = version;
-    await this.config.write();
-  }
-
 }
-
-exports.default = ExtensionCommand;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/cli/extension-command.js"],"names":["UPDATE_ALL","NotUpdatableError","Error","NoUpdatesAvailableError","ExtensionCommand","constructor","config","json","type","isJsonOutput","npm","NPM","appiumHome","knownExtensions","execute","args","cmd","_","isFunction","prototype","executeCmd","bind","list","showInstalled","showUpdates","lsMsg","installedNames","Object","keys","installedExtensions","knownNames","exts","reduce","acc","name","includes","installed","pkgName","ext","data","toPairs","installType","INSTALL_TYPE_NPM","updates","checkForExtensionUpdate","updateVersion","safeUpdate","unsafeUpdateVersion","unsafeUpdate","upToDate","installSpec","version","typeTxt","INSTALL_TYPE_GIT","INSTALL_TYPE_GITHUB","yellow","INSTALL_TYPE_LOCAL","magenta","installTxt","green","grey","updateTxt","upToDateTxt","unsafeUpdateTxt","cyan","console","log","install","packageName","extData","msg","pkgJsonData","linkPackage","getExtensionFields","installPath","split","length","installViaNpm","replace","pkgVer","splits","JSON","stringify","extName","isInstalled","addExtension","getPostInstallText","npmSpec","specMsg","installPackage","pkgDir","path","resolve","err","message","appium","validateExtensionFields","uninstall","fs","rimraf","getInstallPath","removeExtension","update","unsafe","shouldUpdateAll","extsToUpdate","errors","e","current","updateVer","updateExtension","from","to","red","getLatestVersion","getLatestSafeUpgradeVersion","util","compareVersions","write"],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\n\nimport _ from 'lodash';\nimport NPM from './npm';\nimport path from 'path';\nimport { fs, util } from 'appium-support';\nimport { log, spinWith } from './utils';\nimport { INSTALL_TYPE_NPM, INSTALL_TYPE_GIT, INSTALL_TYPE_GITHUB,\n         INSTALL_TYPE_LOCAL } from '../extension-config';\n\nconst UPDATE_ALL = 'installed';\n\nclass NotUpdatableError extends Error {}\nclass NoUpdatesAvailableError extends Error {}\n\nexport default class ExtensionCommand {\n\n  /**\n   * @typedef {Object} ExtensionCommandConstructor\n   * @property {Object} config - the DriverConfig or PluginConfig object used for this command\n   * @property {boolean} json - whether the output of this command should be JSON or text\n   * @property {string} type - DRIVER_TYPE or PLUGIN_TYPE\n   */\n\n  /**\n   * Build an ExtensionCommand\n   *\n   * @param {ExtensionCommandConstructor} opts\n   * @return {ExtensionCommand}\n   */\n  constructor ({config, json, type}) {\n    this.config = config;\n    this.type = type;\n    this.isJsonOutput = json;\n    this.npm = new NPM(this.config.appiumHome);\n    this.knownExtensions = {}; // this needs to be overridden in final class\n  }\n\n  /**\n   * Take a CLI parse and run an extension command based on its type\n   *\n   * @param {object} args - a key/value object with CLI flags and values\n   * @return {object} the result of the specific command which is executed\n   */\n  async execute (args) {\n    const cmd = args[`${this.type}Command`];\n    if (!_.isFunction(ExtensionCommand.prototype[cmd])) {\n      throw new Error(`Cannot handle ${this.type} command ${cmd}`);\n    }\n    const executeCmd = this[cmd].bind(this);\n    return await executeCmd(args);\n  }\n\n  /**\n   * @typedef {Object} ListArgs\n   * @property {boolean} showInstalled - whether should show only installed extensions\n   * @property {boolean} showUpdates - whether should show available updates\n   */\n\n  /**\n   * List extensions\n   *\n   * @param {ListArgs} args\n   * @return {object} map of extension names to extension data\n   */\n  async list ({showInstalled, showUpdates}) {\n    const lsMsg = `Listing ${showInstalled ? 'installed' : 'available'} ${this.type}s`;\n    const installedNames = Object.keys(this.config.installedExtensions);\n    const knownNames = Object.keys(this.knownExtensions);\n    const exts = [...installedNames, ...knownNames].reduce((acc, name) => {\n      if (!acc[name]) {\n        if (installedNames.includes(name)) {\n          acc[name] = {...this.config.installedExtensions[name], installed: true};\n        } else if (!showInstalled) {\n          acc[name] = {pkgName: this.knownExtensions[name], installed: false};\n        }\n      }\n      return acc;\n    }, {});\n\n    // if we want to show whether updates are available, put that behind a spinner\n    await spinWith(this.isJsonOutput, lsMsg, async () => {\n      if (!showUpdates) {\n        return;\n      }\n      for (const [ext, data] of _.toPairs(exts)) {\n        const {installed, installType} = data;\n        if (!installed || installType !== INSTALL_TYPE_NPM) {\n          // don't need to check for updates on exts that aren't installed\n          // also don't need to check for updates on non-npm exts\n          continue;\n        }\n        const updates = await this.checkForExtensionUpdate(ext);\n        data.updateVersion = updates.safeUpdate;\n        data.unsafeUpdateVersion = updates.unsafeUpdate;\n        data.upToDate = updates.safeUpdate === null && updates.unsafeUpdate === null;\n      }\n    });\n\n    // if we're just getting the data, short circuit return here since we don't need to do any\n    // formatting logic\n    if (this.isJsonOutput) {\n      return exts;\n    }\n\n    for (const [\n      name,\n      {installType, installSpec, installed, updateVersion, unsafeUpdateVersion, version, upToDate}\n    ] of _.toPairs(exts)) {\n      let typeTxt;\n      switch (installType) {\n        case INSTALL_TYPE_GIT:\n        case INSTALL_TYPE_GITHUB:\n          typeTxt = `(cloned from ${installSpec})`.yellow;\n          break;\n        case INSTALL_TYPE_LOCAL:\n          typeTxt = `(linked from ${installSpec})`.magenta;\n          break;\n        default:\n          typeTxt = '(NPM)';\n      }\n      const installTxt = installed ?\n        `@${version.yellow} ${('[installed ' + typeTxt + ']').green}` :\n        ' [not installed]'.grey;\n      const updateTxt = showUpdates && updateVersion ?\n        ` [${updateVersion} available]`.magenta :\n        '';\n      const upToDateTxt = showUpdates && upToDate ?\n        ` [Up to date]`.green :\n        '';\n      const unsafeUpdateTxt = showUpdates && unsafeUpdateVersion ?\n        ` [${unsafeUpdateVersion} available (potentially unsafe)]`.cyan :\n        '';\n\n      console.log(`- ${name.yellow}${installTxt}${updateTxt}${upToDateTxt}${unsafeUpdateTxt}`);\n    }\n\n    return exts;\n  }\n\n  /**\n   * @typedef {Object} InstallArgs\n   * @property {string} ext - the name or spec of an extension to install\n   * @property {string} installType - how to install this extension. One of the INSTALL_TYPES\n   * @property {string} [packageName] - for git/github installs, the extension node package name\n   */\n\n  /**\n   * Install an extension\n   *\n   * @param {InstallArgs} args\n   * @return {object} map of all installed extension names to extension data\n   */\n  async install ({ext, installType, packageName}) {\n    log(this.isJsonOutput, `Attempting to find and install ${this.type} '${ext}'`);\n\n    let extData;\n    let installSpec = ext;\n\n    if (packageName && [INSTALL_TYPE_LOCAL, INSTALL_TYPE_NPM].includes(installType)) {\n      throw new Error(`When using --source=${installType}, cannot also use --package`);\n    }\n\n    if (!packageName && [INSTALL_TYPE_GIT, INSTALL_TYPE_GITHUB].includes(installType)) {\n      throw new Error(`When using --source=${installType}, must also use --package`);\n    }\n\n    if (installType === INSTALL_TYPE_LOCAL) {\n      const msg = `Linking ${this.type} from local path`;\n      const pkgJsonData = await spinWith(this.isJsonOutput, msg, async () => (\n        await this.npm.linkPackage(installSpec))\n      );\n      extData = this.getExtensionFields(pkgJsonData);\n      extData.installPath = extData.pkgName;\n    } else if (installType === INSTALL_TYPE_GITHUB) {\n      if (installSpec.split('/').length !== 2) {\n        throw new Error(`Github ${this.type} spec ${installSpec} appeared to be invalid; ` +\n                        'it should be of the form <org>/<repo>');\n      }\n      extData = await this.installViaNpm({ext: installSpec, pkgName: packageName});\n    } else if (installType === INSTALL_TYPE_GIT) {\n      // git urls can have '.git' at the end, but this is not necessary and would complicate the\n      // way we download and name directories, so we can just remove it\n      installSpec = installSpec.replace(/\\.git$/, '');\n      extData = await this.installViaNpm({ext: installSpec, pkgName: packageName});\n    } else {\n      // at this point we have either an npm package or an appium verified extension\n      // name. both of which will be installed via npm.\n      // extensions installed via npm can include versions or tags after the '@'\n      // sign, so check for that. We also need to be careful that package names themselves can\n      // contain the '@' symbol, as in `npm install @appium/fake-driver@1.2.0`\n      let name, pkgVer;\n      const splits = installSpec.split('@');\n      if (installSpec[0] === '@') {\n        // this is the case where we have an npm org included in the package name\n        [name, pkgVer] = [`@${splits[1]}`, splits[2]];\n      } else {\n        // this is the case without an npm org\n        [name, pkgVer] = splits;\n      }\n      let pkgName;\n\n      if (installType === INSTALL_TYPE_NPM) {\n        // if we're installing a named package from npm, we don't need to check\n        // against the appium extension list; just use the installSpec as is\n        pkgName = name;\n      } else {\n        // if we're installing a named appium driver (like 'xcuitest') we need to\n        // dereference the actual npm package ('appiupm-xcuitest-driver'), so\n        // check it exists and get the correct package\n        const knownNames = Object.keys(this.knownExtensions);\n        if (!_.includes(knownNames, name)) {\n          const msg = `Could not resolve ${this.type}; are you sure it's in the list ` +\n                      `of supported ${this.type}s? ${JSON.stringify(knownNames)}`;\n          throw new Error(msg);\n        }\n        pkgName = this.knownExtensions[name];\n        // given that we'll use the install type in the driver json, store it as\n        // 'npm' now\n        installType = INSTALL_TYPE_NPM;\n      }\n\n      extData = await this.installViaNpm({ext, pkgName, pkgVer});\n    }\n\n    const extName = extData[`${this.type}Name`];\n    delete extData[`${this.type}Name`];\n\n    if (this.config.isInstalled(extName)) {\n      throw new Error(`A ${this.type} named '${extName}' is already installed. ` +\n                      `Did you mean to update? 'appium ${this.type} update'. See ` +\n                      `installed ${this.type}s with 'appium ${this.type} list --installed'.`);\n    }\n\n    extData.installType = installType;\n    extData.installSpec = installSpec;\n    await this.config.addExtension(extName, extData);\n\n    // log info for the user\n    log(this.isJsonOutput, this.getPostInstallText({extName, extData}));\n\n    return this.config.installedExtensions;\n  }\n\n  /**\n   * @typedef {Object} InstallViaNpmArgs\n   * @property {string} ext - the name or spec of an extension to install\n   * @property {string} pkgName - the NPM package name of the extension\n   * @property {string} [pkgVer] - the specific version of the NPM package\n   */\n\n  /**\n   * Install an extension via NPM\n   *\n   * @param {InstallViaNpmArgs} args\n   */\n  async installViaNpm ({ext, pkgName, pkgVer}) {\n    const npmSpec = `${pkgName}${pkgVer ? '@' + pkgVer : ''}`;\n    const specMsg = npmSpec === ext ? '' : ` using NPM install spec '${npmSpec}'`;\n    const msg = `Installing '${ext}'${specMsg}`;\n    try {\n      const pkgJsonData = await spinWith(this.isJsonOutput, msg, async () => (\n        await this.npm.installPackage({\n          pkgDir: path.resolve(this.config.appiumHome, pkgName),\n          pkgName,\n          pkgVer\n        })\n      ));\n      const extData = this.getExtensionFields(pkgJsonData);\n      extData.installPath = pkgName;\n      return extData;\n    } catch (err) {\n      throw new Error(`Encountered an error when installing package: ${err.message}`);\n    }\n  }\n\n  /**\n   * @typedef {Object} ExtensionArgs\n   * @property {string} extName - the name of an extension\n   * @property {object} extData - the data for an installed extension\n   */\n\n  /**\n   * Get the text which should be displayed to the user after an extension has been installed. This\n   * is designed to be overridden by drivers/plugins with their own particular text.\n   *\n   * @param {ExtensionArgs} args\n   */\n  getPostInstallText (/*{extName, extData}*/) {\n    throw new Error('Must be implemented in final class');\n  }\n\n  /**\n   * Take an NPM module's package.json and extract Appium driver information from a special\n   * 'appium' field in the JSON data. We need this information to e.g. determine which class to\n   * load as the main driver class, or to be able to detect incompatibilities between driver and\n   * appium versions.\n   *\n   * @param {object} pkgJsonData - the package.json data for a driver module, as if it had been\n   * straightforwardly 'require'd\n   */\n  getExtensionFields (pkgJsonData) {\n    if (!pkgJsonData.appium) {\n      throw new Error(`Installed driver did not have an 'appium' section in its ` +\n                      `package.json file as expected`);\n    }\n    const {appium, name, version} = pkgJsonData;\n    this.validateExtensionFields(appium);\n\n    return {...appium, pkgName: name, version};\n  }\n\n  /**\n   * For any package.json fields which a particular type of extension requires, validate the\n   * presence and form of those fields on the package.json data, throwing an error if anything is\n   * amiss.\n   *\n   * @param {object} appiumPkgData - the data in the \"appium\" field of package.json for an\n   * extension\n   */\n  validateExtensionFields (/*appiumPkgData*/) {\n    throw new Error('Must be implemented in final class');\n  }\n\n  /**\n   * @typedef {Object} UninstallArgs\n   * @property {string} ext - the name or spec of an extension to uninstall\n   */\n\n  /**\n   * Uninstall an extension\n   *\n   * @param {UninstallArgs} args\n   * @return {object} map of all installed extension names to extension data\n   */\n  async uninstall ({ext}) {\n    if (!this.config.isInstalled(ext)) {\n      throw new Error(`Can't uninstall ${this.type} '${ext}'; it is not installed`);\n    }\n    try {\n      await fs.rimraf(this.config.getInstallPath(ext));\n    } finally {\n      await this.config.removeExtension(ext);\n    }\n    log(this.isJsonOutput, `Successfully uninstalled ${this.type} '${ext}'`.green);\n    return this.config.installedExtensions;\n  }\n\n  /**\n   * @typedef {Object} ExtensionUpdateOpts\n   * @property {string} ext - the name of the extension to update\n   * @property {boolean} unsafe - if true, will perform unsafe updates past major revision\n   * boundaries\n   */\n\n  /**\n   * @typedef {Object} UpdateReport\n   * @property {string} from - version updated from\n   * @property {string} to - version updated to\n   */\n\n  /**\n   * @typedef {Object} ExtensionUpdateResult\n   * @property {Object} errors - map of ext names to error objects\n   * @property {Object} updates - map of ext names to {@link UpdateReport}s\n   */\n\n  /**\n   * Attempt to update one or more drivers using NPM\n   *\n   * @param {ExtensionUpdateOpts} updateSpec\n   * @return {ExtensionUpdateResult}\n   */\n  async update ({ext, unsafe}) {\n    const shouldUpdateAll = ext === UPDATE_ALL;\n    // if we're specifically requesting an update for an extension, make sure it's installed\n    if (!shouldUpdateAll && !this.config.isInstalled(ext)) {\n      throw new Error(`The ${this.type} '${ext}' was not installed, so can't be updated`);\n    }\n    const extsToUpdate = shouldUpdateAll ? Object.keys(this.config.installedExtensions) : [ext];\n\n    // 'errors' will have ext names as keys and error objects as values\n    const errors = {};\n\n    // 'updates' will have ext names as keys and update objects as values, where an update\n    // object is of the form {from: versionString, to: versionString}\n    const updates = {};\n\n    for (const e of extsToUpdate) {\n      try {\n        await spinWith(this.isJsonOutput, `Checking if ${this.type} '${e}' is updatable`, () => {\n          if (this.config.installedExtensions[e].installType !== INSTALL_TYPE_NPM) {\n            throw new NotUpdatableError();\n          }\n        });\n        const update = await spinWith(this.isJsonOutput, `Checking if ${this.type} '${e}' needs an update`, async () => {\n          const update = await this.checkForExtensionUpdate(e);\n          if (!(update.safeUpdate || update.unsafeUpdate)) {\n            throw new NoUpdatesAvailableError();\n          }\n          return update;\n        });\n        if (!unsafe && !update.safeUpdate) {\n          throw new Error(`The ${this.type} '${e}' has a major revision update ` +\n                          `(${update.current} => ${update.unsafeUpdate}), which could include ` +\n                          `breaking changes. If you want to apply this update, re-run with --unsafe`);\n        }\n        const updateVer = unsafe && update.unsafeUpdate ? update.unsafeUpdate : update.safeUpdate;\n        await spinWith(\n          this.isJsonOutput,\n          `Updating driver '${e}' from ${update.current} to ${updateVer}`,\n          async () => await this.updateExtension(e, updateVer)\n        );\n        updates[e] = {from: update.current, to: updateVer};\n      } catch (err) {\n        errors[e] = err;\n      }\n    }\n\n    log(this.isJsonOutput, 'Update report:');\n    for (const [e, update] of _.toPairs(updates)) {\n      log(this.isJsonOutput, `- ${this.type} ${e} updated: ${update.from} => ${update.to}`.green);\n    }\n    for (const [e, err] of _.toPairs(errors)) {\n      if (err instanceof NotUpdatableError) {\n        log(this.isJsonOutput, `- '${e}' was not installed via npm, so we could not check ` +\n                               `for updates`.yellow);\n      } else if (err instanceof NoUpdatesAvailableError) {\n        log(this.isJsonOutput, `- '${e}' had no updates available`.yellow);\n      } else {\n        // otherwise, make it pop with red!\n        log(this.isJsonOutput, `- '${e}' failed to update: ${err}`.red);\n      }\n    }\n\n    return {updates, errors};\n  }\n\n  /**\n   * @typedef PossibleUpdates\n   * @property {string} current - current version\n   * @property {string|null} safeUpdate - version we can safely update to if it exists, or null\n   * @property {string|null} unsafeUpdate - version we can unsafely update to if it exists, or null\n   */\n\n  /**\n   * Given an extension name, figure out what its highest possible version upgrade is, and also the\n   * highest possible safe upgrade.\n   *\n   * @param {string} ext - name of extension\n   * @return {PossibleUpdates}\n   */\n  async checkForExtensionUpdate (ext) {\n    // TODO decide how we want to handle beta versions?\n    // this is a helper method, 'ext' is assumed to already be installed here, and of the npm\n    // install type\n    const {version, pkgName} = this.config.installedExtensions[ext];\n    let unsafeUpdate = await this.npm.getLatestVersion(pkgName);\n    let safeUpdate = await this.npm.getLatestSafeUpgradeVersion(pkgName, version);\n    if (!util.compareVersions(unsafeUpdate, '>', version)) {\n      // the latest version is not greater than the current version, so there's no possible update\n      unsafeUpdate = null;\n      safeUpdate = null;\n    }\n    if (unsafeUpdate && unsafeUpdate === safeUpdate) {\n      // the latest update is the same as the safe update, which means it's not actually unsafe\n      unsafeUpdate = null;\n    }\n    if (safeUpdate && !util.compareVersions(safeUpdate, '>', version)) {\n      // even the safe update is not later than the current, so it is not actually an update\n      safeUpdate = null;\n    }\n    return {current: version, safeUpdate, unsafeUpdate};\n  }\n\n  /**\n   * Actually update an extension installed by NPM, using the NPM cli. And update the installation\n   * manifest.\n   *\n   * @param {string} ext - name of extension to update\n   * @param {string} version - version string identifier to update extension to\n   */\n  async updateExtension (ext, version) {\n    const {pkgName} = this.config.installedExtensions[ext];\n    await this.installViaNpm({ext, pkgName, pkgVer: version});\n    this.config.installedExtensions[ext].version = version;\n    await this.config.write();\n  }\n}\n"],"file":"lib/cli/extension-command.js","sourceRoot":"../../.."}
+exports.ExtensionCommand = ExtensionCliCommand;
+exports.default = ExtensionCliCommand;
+/**
+ * Options for the {@linkcode ExtensionCliCommand} 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 ExtensionCliCommand.list}.
+ *
+ * @typedef ExtensionListMetadata
+ * @property {boolean} installed - If `true`, the extension is installed
+ * @property {boolean} upToDate - If the extension is installed and the latest
+ * @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 {string} [updateError] - Update check error message (if present)
+ * @property {boolean} [devMode] - If Appium is run from an extension's working copy
+ */
+/**
+ * @typedef {import('@appium/types').ExtensionType} ExtensionType
+ * @typedef {import('@appium/types').DriverType} DriverType
+ * @typedef {import('@appium/types').PluginType} PluginType
+ */
+/**
+ * @template {ExtensionType} ExtType
+ * @typedef {import('appium/types').ExtRecord<ExtType>} ExtRecord
+ */
+/**
+ * @template {ExtensionType} ExtType
+ * @typedef {import('../extension/extension-config').ExtensionConfig<ExtType>} ExtensionConfig
+ */
+/**
+ * @template {ExtensionType} ExtType
+ * @typedef {import('appium/types').ExtMetadata<ExtType>} ExtMetadata
+ */
+/**
+ * @template {ExtensionType} ExtType
+ * @typedef {import('appium/types').ExtManifest<ExtType>} ExtManifest
+ */
+/**
+ * @template {ExtensionType} ExtType
+ * @typedef {import('appium/types').ExtPackageJson<ExtType>} ExtPackageJson
+ */
+/**
+ * @template {ExtensionType} ExtType
+ * @typedef {import('appium/types').ExtInstallReceipt<ExtType>} ExtInstallReceipt
+ */
+/**
+ * Possible return value for {@linkcode ExtensionCliCommand.list}
+ * @template {ExtensionType} ExtType
+ * @typedef {Partial<ExtManifest<ExtType>> & Partial<ExtensionListMetadata>} ExtensionListData
+ */
+/**
+ * @template {ExtensionType} ExtType
+ * @typedef {ExtManifest<ExtType> & ExtensionListMetadata} InstalledExtensionListData
+ */
+/**
+ * Return value of {@linkcode ExtensionCliCommand.list}.
+ * @template {ExtensionType} ExtType
+ * @typedef {Record<string,ExtensionListData<ExtType>>} ExtensionList
+ */
+/**
+ * Options for {@linkcode ExtensionCliCommand._run}.
+ * @typedef RunOptions
+ * @property {string} installSpec - name of the extension to run a script from
+ * @property {string} scriptName - name of the script to run
+ * @property {string[]} [extraArgs] - arguments to pass to the script
+ * @property {boolean} [bufferOutput] - if true, will buffer the output of the script and return it
+ */
+/**
+ * Return value of {@linkcode ExtensionCliCommand._run}
+ *
+ * @typedef RunOutput
+ * @property {string} [error] - error message if script ran unsuccessfully, otherwise undefined
+ * @property {string[]} [output] - script output if `bufferOutput` was `true` in {@linkcode RunOptions}
+ */
+/**
+ * Options for {@linkcode ExtensionCliCommand._update}.
+ * @typedef ExtensionUpdateOpts
+ * @property {string} installSpec - the name of the extension to update
+ * @property {boolean} unsafe - if true, will perform unsafe updates past major revision boundaries
+ */
+/**
+ * Return value of {@linkcode ExtensionCliCommand._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 ExtensionCliCommand._update}.
+ * @typedef UpdateReport
+ * @property {string} from - version the extension was updated from
+ * @property {string} to - version the extension was updated to
+ */
+/**
+ * Options for {@linkcode ExtensionCliCommand._uninstall}.
+ * @typedef UninstallOpts
+ * @property {string} installSpec - the name or spec of an extension to uninstall
+ */
+/**
+ * Used by {@linkcode ExtensionCliCommand.getPostInstallText}
+ * @typedef ExtensionArgs
+ * @property {string} extName - the name of an extension
+ * @property {object} extData - the data for an installed extension
+ */
+/**
+ * Options for {@linkcode ExtensionCliCommand.installViaNpm}
+ * @typedef InstallViaNpmArgs
+ * @property {string} installSpec - the name or spec of an extension to install
+ * @property {string} pkgName - the NPM package name of the extension
+ * @property {import('appium/types').InstallType} installType - type of install
+ * @property {string} [pkgVer] - the specific version of the NPM package
+ */
+/**
+ * Object returned by {@linkcode ExtensionCliCommand.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 ExtensionCliCommand._install}
+ * @typedef InstallOpts
+ * @property {string} installSpec - the name or spec of an extension to install
+ * @property {InstallType} installType - how to install this extension. One of the INSTALL_TYPES
+ * @property {string} [packageName] - for git/github installs, the extension node package name
+ */
+/**
+ * @template {ExtensionType} ExtType
+ * @typedef {ExtType extends DriverType ? typeof import('../constants').KNOWN_DRIVERS : ExtType extends PluginType ? typeof import('../constants').KNOWN_PLUGINS : never} KnownExtensions
+ */
+/**
+ * @typedef ListOptions
+ * @property {boolean} showInstalled - whether should show only installed extensions
+ * @property {boolean} showUpdates - whether should show available updates
+ * @property {boolean} [verbose] - whether to show additional data from the extension
+ */
+/**
+ * Opts for {@linkcode ExtensionCliCommand.getInstallationReceipt}
+ * @template {ExtensionType} ExtType
+ * @typedef GetInstallationReceiptOpts
+ * @property {string} installPath
+ * @property {string} installSpec
+ * @property {ExtPackageJson<ExtType>} pkg
+ * @property {InstallType} installType
+ */
+/**
+ * @typedef {import('appium/types').InstallType} InstallType
+ */
+//# sourceMappingURL=extension-command.js.map