appium 3.2.1 → 3.3.0

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

@@ -60,19 +60,15 @@ 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'));
+    return lodash_1.default.omit(receipt, 'driverName', 'pluginName');
 }
 /**
  * Fetches the remote extension version requirements
  *
- * @param {string} pkgName Extension name
- * @param {string} [pkgVer] Extension version (if not provided then the latest is assumed)
- * @returns {Promise<[string, string|null]>}
+ * @param pkgName Extension name
+ * @param [pkgVer] Extension version (if not provided then the latest is assumed)
  */
 async function getRemoteExtensionVersionReq(pkgName, pkgVer) {
     const allDeps = await support_1.npm.getPackageInfo(`${pkgName}${pkgVer ? `@${pkgVer}` : ``}`, ['peerDependencies', 'dependencies']);
@@ -80,28 +76,24 @@ async function getRemoteExtensionVersionReq(pkgName, pkgVer) {
         .find(([name]) => name === 'appium');
     return [utils_2.npmPackage.version, requiredVersionPair ? requiredVersionPair[1] : null];
 }
-/**
- * @template {ExtensionType} ExtType
- */
 class ExtensionCliCommand {
     /**
      * This is the `DriverConfig` or `PluginConfig`, depending on `ExtType`.
-     * @type {ExtensionConfig<ExtType>}
      */
     config;
     /**
      * {@linkcode Record} of official plugins or drivers.
-     * @type {KnownExtensions<ExtType>}
      */
     knownExtensions;
     /**
      * If `true`, command output has been requested as JSON.
-     * @type {boolean}
      */
     isJsonOutput;
+    log;
     /**
-     * Build an ExtensionCommand
-     * @param {ExtensionCommandOptions<ExtType>} opts
+     * Creates an extension command instance.
+     *
+     * @param opts - constructor options containing extension config and JSON mode
      */
     constructor({ config, json }) {
         this.config = config;
@@ -115,24 +107,10 @@ class ExtensionCliCommand {
         return this.config.extensionType;
     }
     /**
-     * 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'));
-    }
-    /**
-     * Take a CLI parse and run an extension command based on its type
+     * Executes an extension subcommand from parsed CLI args.
      *
-     * @param {object} args - a key/value object with CLI flags and values
-     * @return {Promise<object>} the result of the specific command which is executed
+     * @param args - parsed CLI argument object
+     * @returns result of the executed extension subcommand
      */
     async execute(args) {
         const cmd = args[`${this.type}Command`];
@@ -143,11 +121,10 @@ class ExtensionCliCommand {
         return await executeCmd(args);
     }
     /**
-     * List extensions
+     * Lists available/installed extensions and optional update metadata.
      *
-     * @template {ExtensionType} ExtType
-     * @param {ListOptions} opts
-     * @return {Promise<ExtensionList<ExtType>>} map of extension names to extension data
+     * @param opts - list command options
+     * @returns map of extension names to list data
      */
     async list({ showInstalled, showUpdates, verbose = false }) {
         const listData = this._buildListData(showInstalled);
@@ -166,284 +143,33 @@ class ExtensionCliCommand {
         return await this._displayNormalListOutput(listData, showUpdates);
     }
     /**
-     * Build the initial list data structure from installed and known extensions
-     *
-     * @template {ExtensionType} ExtType
-     * @param {boolean} showInstalled
-     * @returns {ExtensionList<ExtType>}
-     * @private
-     */
-    _buildListData(showInstalled) {
-        const installedNames = Object.keys(this.config.installedExtensions);
-        const knownNames = Object.keys(this.knownExtensions);
-        return [...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>} */ ({}));
-    }
-    /**
-     * Check for available updates for installed extensions
-     *
-     * @template {ExtensionType} ExtType
-     * @param {ExtensionList<ExtType>} listData
-     * @param {boolean} showUpdates
-     * @param {string} lsMsg
-     * @returns {Promise<void>}
-     * @private
-     */
-    async _checkForUpdates(listData, showUpdates, lsMsg) {
-        await (0, utils_1.spinWith)(this.isJsonOutput, lsMsg, async () => {
-            // We'd like to still show lsMsg even if showUpdates is false
-            if (!showUpdates) {
-                return;
-            }
-            // Filter to only extensions that need update checks (installed npm packages)
-            const extensionsToCheck = lodash_1.default.toPairs(listData).filter(([, data]) => data.installed && data.installType === extension_config_1.INSTALL_TYPE_NPM);
-            await bluebird_1.default.map(extensionsToCheck, async ([ext, data]) => {
-                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;
-                }
-            }, { concurrency: MAX_CONCURRENT_REPO_FETCHES });
-        });
-    }
-    /**
-     * Add repository URLs to list data for all extensions
-     *
-     * @template {ExtensionType} ExtType
-     * @param {ExtensionList<ExtType>} listData
-     * @returns {Promise<void>}
-     * @private
-     */
-    async _addRepositoryUrlsToListData(listData) {
-        await (0, utils_1.spinWith)(this.isJsonOutput, 'Fetching repository information', async () => {
-            await bluebird_1.default.map(lodash_1.default.values(listData), async (data) => {
-                const repoUrl = await this._getRepositoryUrl(data);
-                if (repoUrl) {
-                    data.repositoryUrl = repoUrl;
-                }
-            }, { concurrency: MAX_CONCURRENT_REPO_FETCHES });
-        });
-    }
-    /**
-     * Display normal formatted output
-     *
-     * @template {ExtensionType} ExtType
-     * @param {ExtensionList<ExtType>} listData
-     * @param {boolean} showUpdates
-     * @returns {Promise<ExtensionList<ExtType>>}
-     * @private
-     */
-    async _displayNormalListOutput(listData, showUpdates) {
-        for (const [name, data] of lodash_1.default.toPairs(listData)) {
-            const line = await this._formatExtensionLine(name, data, showUpdates);
-            this.log.log(line);
-        }
-        return listData;
-    }
-    /**
-     * Format a single extension line for display
-     *
-     * @template {ExtensionType} ExtType
-     * @param {string} name
-     * @param {ExtensionListData<ExtType>} data
-     * @param {boolean} showUpdates
-     * @returns {Promise<string>}
-     * @private
-     */
-    async _formatExtensionLine(name, data, showUpdates) {
-        if (data.installed) {
-            const installTxt = this._formatInstallText(/** @type {InstalledExtensionListData<ExtType>} */ (data));
-            const updateTxt = showUpdates ? this._formatUpdateText(/** @type {InstalledExtensionListData<ExtType>} */ (data)) : '';
-            return `- ${name.yellow}${installTxt}${updateTxt}`;
-        }
-        const installTxt = ' [not installed]'.grey;
-        return `- ${name.yellow}${installTxt}`;
-    }
-    /**
-     * Format installation status text
-     *
-     * @template {ExtensionType} ExtType
-     * @param {InstalledExtensionListData<ExtType>} data
-     * @returns {string}
-     * @private
-     */
-    _formatInstallText(data) {
-        const { installType, installSpec, version } = 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)';
-        }
-        return `@${version.yellow} ${('[installed ' + typeTxt + ']').green}`;
-    }
-    /**
-     * Format update information text
-     *
-     * @template {ExtensionType} ExtType
-     * @param {InstalledExtensionListData<ExtType>} data
-     * @returns {string}
-     * @private
-     */
-    _formatUpdateText(data) {
-        const { updateVersion, unsafeUpdateVersion, upToDate, updateError } = data;
-        if (updateError) {
-            return ` [Cannot check for updates: ${updateError}]`.red;
-        }
-        let txt = '';
-        if (updateVersion) {
-            txt += ` [${updateVersion} available]`.magenta;
-        }
-        if (upToDate) {
-            txt += ` [Up to date]`.green;
-        }
-        if (unsafeUpdateVersion) {
-            txt += ` [${unsafeUpdateVersion} available (potentially unsafe)]`.cyan;
-        }
-        return txt;
-    }
-    /**
-     * Get repository URL from package data
-     *
-     * @template {ExtensionType} ExtType
-     * @param {ExtensionListData<ExtType>} data
-     * @returns {Promise<string|null>}
-     * @private
-     */
-    async _getRepositoryUrl(data) {
-        if (data.installed && data.installPath) {
-            return await this._getRepositoryUrlFromInstalled(
-            /** @type {InstalledExtensionListData<ExtType>} */ (data));
-        }
-        if (data.pkgName && !data.installed) {
-            return await this._getRepositoryUrlFromNpm(data.pkgName);
-        }
-        return null;
-    }
-    /**
-     * Get repository URL from installed extension's package.json
-     *
-     * @template {ExtensionType} ExtType
-     * @param {InstalledExtensionListData<ExtType>} data
-     * @returns {Promise<string|null>}
-     * @private
-     */
-    async _getRepositoryUrlFromInstalled(data) {
-        try {
-            const pkgJsonPath = node_path_1.default.join(data.installPath, 'package.json');
-            if (await support_1.fs.exists(pkgJsonPath)) {
-                const pkg = JSON.parse(await support_1.fs.readFile(pkgJsonPath, 'utf8'));
-                if (pkg.repository) {
-                    if (typeof pkg.repository === 'string') {
-                        return pkg.repository;
-                    }
-                    if (pkg.repository.url) {
-                        return pkg.repository.url.replace(/^git\+/, '').replace(/\.git$/, '');
-                    }
-                }
-            }
-        }
-        catch {
-            // Ignore errors reading package.json
-        }
-        return null;
-    }
-    /**
-     * Get repository URL from npm for a package name
+     * Logs a message and returns an {@linkcode Error} to throw.
      *
-     * @param {string} pkgName
-     * @returns {Promise<string|null>}
-     * @private
-     */
-    async _getRepositoryUrlFromNpm(pkgName) {
-        try {
-            const repoInfo = await support_1.npm.getPackageInfo(pkgName, ['repository']);
-            // When requesting only 'repository', npm.getPackageInfo returns the repository object directly
-            if (repoInfo) {
-                if (typeof repoInfo === 'string') {
-                    return repoInfo;
-                }
-                if (repoInfo.url) {
-                    return repoInfo.url.replace(/^git\+/, '').replace(/\.git$/, '');
-                }
-            }
-        }
-        catch {
-            // Ignore errors fetching from npm
-        }
-        return null;
-    }
-    /**
-     * Checks whether the given extension is compatible with the currently installed server
+     * 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 a `never` return annotation, which does not imply a thrown exception.
      *
-     * @param {InstallViaNpmArgs} installViaNpmOpts
-     * @returns {Promise<void>}
+     * @throws {Error}
      */
-    async _checkInstallCompatibility({ installSpec, pkgName, pkgVer, installType }) {
-        if (extension_config_1.INSTALL_TYPE_NPM !== installType) {
-            return;
-        }
-        await (0, utils_1.spinWith)(this.isJsonOutput, `Checking if '${pkgName}' is compatible`, async () => {
-            const [serverVersion, extVersionRequirement] = await getRemoteExtensionVersionReq(pkgName, pkgVer);
-            if (serverVersion && extVersionRequirement && !semver.satisfies(serverVersion, extVersionRequirement)) {
-                throw this._createFatalError(`'${installSpec}' cannot be installed because the server version it requires (${extVersionRequirement}) ` +
-                    `does not meet the currently installed one (${serverVersion}). Please install ` +
-                    `a compatible server version first.`);
-            }
-        });
+    _createFatalError(message) {
+        return new Error(this.log.decorate(message, 'error'));
     }
     /**
-     * Install an extension
+     * Build the initial list data structure from installed and known extensions
      *
-     * @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`
@@ -455,9 +181,9 @@ class ExtensionCliCommand {
             installViaNpmOpts = {
                 installSpec,
                 installType,
-                pkgName: /** @type {string} */ (packageName),
+                pkgName: packageName,
             };
-            probableExtName = /** @type {string} */ (packageName);
+            probableExtName = packageName;
         }
         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
@@ -466,12 +192,13 @@ class ExtensionCliCommand {
             installViaNpmOpts = {
                 installSpec,
                 installType,
-                pkgName: /** @type {string} */ (packageName),
+                pkgName: packageName,
             };
-            probableExtName = /** @type {string} */ (packageName);
+            probableExtName = packageName;
         }
         else {
-            let pkgName, pkgVer;
+            let pkgName;
+            let pkgVer;
             if (installType === extension_config_1.INSTALL_TYPE_LOCAL) {
                 pkgName = node_path_1.default.isAbsolute(installSpec) ? installSpec : node_path_1.default.resolve(installSpec);
             }
@@ -522,11 +249,10 @@ class ExtensionCliCommand {
                 `installed ${this.type}s with "appium ${this.type} list --installed".`);
         }
         await this._checkInstallCompatibility(installViaNpmOpts);
-        receipt = await this.installViaNpm(installViaNpmOpts);
+        const 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`)];
+        const extName = receipt[`${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. ` +
@@ -535,7 +261,6 @@ class ExtensionCliCommand {
         }
         // 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),
@@ -561,146 +286,34 @@ class ExtensionCliCommand {
         return this.config.installedExtensions;
     }
     /**
-     * Install an extension via NPM
+     * Uninstall an extension.
+     *
+     * First tries to do this via `npm uninstall`, but if that fails, just `rm -rf`'s the extension dir.
      *
-     * @param {InstallViaNpmArgs} args
-     * @returns {Promise<ExtInstallReceipt<ExtType>>}
+     * Will only remove the extension from the manifest if it has been successfully removed.
+     *
+     * @return map of all installed extension names to extension data (without the extension just uninstalled)
      */
-    async installViaNpm({ installSpec, pkgName, pkgVer, installType }) {
-        const installMsg = `Installing '${installSpec}'`;
-        const validateMsg = `Validating '${installSpec}'`;
-        // the string used for installation is either <name>@<ver> in the case of a standard NPM
-        // package, or whatever the user sent in otherwise.
-        const installStr = installType === extension_config_1.INSTALL_TYPE_NPM ? `${pkgName}${pkgVer ? `@${pkgVer}` : ''}` : installSpec;
-        const appiumHome = this.config.appiumHome;
-        try {
-            const { pkg, installPath } = await (0, utils_1.spinWith)(this.isJsonOutput, installMsg, async () => await support_1.npm.installPackage(appiumHome, installStr, { pkgName, installType }));
-            await (0, utils_1.spinWith)(this.isJsonOutput, validateMsg, async () => {
-                this.validatePackageJson(pkg, installSpec);
-            });
-            return this.getInstallationReceipt({
-                pkg,
-                installPath,
-                installType,
-                installSpec,
-            });
+    async _uninstall({ installSpec }) {
+        if (!this.config.isInstalled(installSpec)) {
+            throw this._createFatalError(`Can't uninstall ${this.type} '${installSpec}'; it is not installed`);
         }
-        catch (err) {
-            throw this._createFatalError(`Encountered an error when installing package: ${err.message}`);
+        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 (0, utils_1.spinWith)(this.isJsonOutput, `Uninstalling ${this.type} '${installSpec}'`, async () => {
+            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;
     }
     /**
-     * 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.
+     * Attempt to update one or more drivers using NPM
      *
-     * @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');
-    }
-    /**
-     * 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;
-        const strVersion = /** @type {string} */ (version);
-        /** @type {import('appium/types').InternalMetadata} */
-        const internal = {
-            pkgName: /** @type {string} */ (name),
-            version: strVersion,
-            installType,
-            installSpec,
-            installPath,
-            appiumVersion: peerDependencies?.appium,
-        };
-        /** @type {ExtMetadata<ExtType>} */
-        const extMetadata = appium;
-        return {
-            ...internal,
-            ...extMetadata,
-        };
-    }
-    /**
-     * 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;
-    }
-    /**
-     * 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');
-    }
-    /**
-     * 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 (0, utils_1.spinWith)(this.isJsonOutput, `Uninstalling ${this.type} '${installSpec}'`, async () => {
-            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;
-    }
-    /**
-     * Attempt to update one or more drivers using NPM
-     *
-     * @param {ExtensionUpdateOpts} updateSpec
-     * @return {Promise<ExtensionUpdateResult>}
      */
     async _update({ installSpec, unsafe }) {
         const shouldUpdateAll = installSpec === UPDATE_ALL;
@@ -712,11 +325,9 @@ class ExtensionCliCommand {
             ? 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 {
@@ -738,6 +349,9 @@ class ExtensionCliCommand {
                         `breaking changes. If you want to apply this update, re-run with --unsafe`);
                 }
                 const updateVer = unsafe && update.unsafeUpdate ? update.unsafeUpdate : update.safeUpdate;
+                if (!updateVer) {
+                    throw new NoUpdatesAvailableError();
+                }
                 await (0, utils_1.spinWith)(this.isJsonOutput, `Updating ${this.type} '${e}' from ${update.current} to ${updateVer}`, async () => await this.updateExtension(e, updateVer));
                 // if we're doing a safe update, but an unsafe update is also available, let the user know
                 if (!unsafe && update.unsafeUpdate) {
@@ -774,15 +388,13 @@ class ExtensionCliCommand {
      * 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>}
+     * @param ext - name of extension
      */
     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)) {
@@ -800,46 +412,10 @@ class ExtensionCliCommand {
         }
         return { current: version, safeUpdate, unsafeUpdate };
     }
-    /**
-     * 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);
-    }
-    /**
-     * 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, node_child_process_1.spawn)(process.execPath, [script, ...args], {
-            cwd,
-            stdio: 'inherit',
-            ...opts,
-        });
-    }
     /**
      * Runs doctor checks for the given extension.
      *
-     * @param {DoctorOptions} opts
-     * @returns {Promise<number>} The amount of Doctor checks that were
+     * @returns The amount of Doctor checks that were
      * successfully loaded and executed for the given extension
      * @throws {Error} If any of the mandatory Doctor checks fails.
      */
@@ -867,7 +443,8 @@ class ExtensionCliCommand {
             throw this._createFatalError(`The 'doctor' entry in the package manifest '${packageJsonPath}' must be a proper object ` +
                 `containing the 'checks' key with the array of script paths`);
         }
-        const paths = doctorSpec.checks.map((/** @type {string} */ p) => {
+        const paths = doctorSpec.checks
+            .map((p) => {
             const scriptPath = node_path_1.default.resolve(moduleRoot, p);
             if (!node_path_1.default.normalize(scriptPath).startsWith(node_path_1.default.normalize(moduleRoot))) {
                 this.log.error(`The doctor check script '${p}' from the package manifest '${packageJsonPath}' must be located ` +
@@ -875,8 +452,8 @@ class ExtensionCliCommand {
                 return null;
             }
             return scriptPath;
-        }).filter(Boolean);
-        /** @type {Promise[]} */
+        })
+            .filter((p) => Boolean(p));
         const loadChecksPromises = [];
         for (const p of paths) {
             const promise = (async () => {
@@ -891,8 +468,7 @@ class ExtensionCliCommand {
             })();
             loadChecksPromises.push(promise);
         }
-        const isDoctorCheck = (/** @type {any} */ x) => ['diagnose', 'fix', 'hasAutofix', 'isOptional'].every((method) => lodash_1.default.isFunction(x?.[method]));
-        /** @type {import('@appium/types').IDoctorCheck[]} */
+        const isDoctorCheck = (x) => ['diagnose', 'fix', 'hasAutofix', 'isOptional'].every((method) => lodash_1.default.isFunction(x?.[method]));
         const checks = lodash_1.default.flatMap((await bluebird_1.default.all(loadChecksPromises)).filter(Boolean).map(lodash_1.default.toPairs))
             .map(([, value]) => value)
             .filter(isDoctorCheck);
@@ -916,10 +492,8 @@ class ExtensionCliCommand {
      * `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 }) {
+    async _run({ installSpec, scriptName, extraArgs = [], bufferOutput = false, }) {
         if (!this.config.isInstalled(installSpec)) {
             throw this._createFatalError(`The ${this.type} "${installSpec}" is not installed`);
         }
@@ -948,7 +522,7 @@ class ExtensionCliCommand {
             this.log.ok(`Successfully retrieved the list of scripts`.green);
             return {};
         }
-        if (!(scriptName in /** @type {Record<string,string>} */ (extScripts))) {
+        if (!(scriptName in extScripts)) {
             throw this._createFatalError(`The ${this.type} named '${installSpec}' does not support the script: '${scriptName}'`);
         }
         const scriptPath = extScripts[scriptName];
@@ -1003,21 +577,335 @@ class ExtensionCliCommand {
             throw this._createFatalError(message);
         }
     }
+    _buildListData(showInstalled) {
+        const installedNames = Object.keys(this.config.installedExtensions);
+        const knownNames = Object.keys(this.knownExtensions);
+        return [...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;
+        }, {});
+    }
+    /**
+     * Install an extension via NPM
+     *
+     */
+    async installViaNpm({ installSpec, pkgName, pkgVer, installType, }) {
+        const installMsg = `Installing '${installSpec}'`;
+        const validateMsg = `Validating '${installSpec}'`;
+        // the string used for installation is either <name>@<ver> in the case of a standard NPM
+        // package, or whatever the user sent in otherwise.
+        const installStr = installType === extension_config_1.INSTALL_TYPE_NPM ? `${pkgName}${pkgVer ? `@${pkgVer}` : ''}` : installSpec;
+        const appiumHome = this.config.appiumHome;
+        try {
+            const { pkg, installPath } = await (0, utils_1.spinWith)(this.isJsonOutput, installMsg, async () => await support_1.npm.installPackage(appiumHome, installStr, { pkgName, installType }));
+            const validatedPkg = await (0, utils_1.spinWith)(this.isJsonOutput, validateMsg, async () => this.validatePackageJson(pkg, installSpec));
+            return this.getInstallationReceipt({
+                pkg: validatedPkg,
+                installPath,
+                installType,
+                installSpec,
+            });
+        }
+        catch (err) {
+            throw this._createFatalError(`Encountered an error when installing package: ${err.message}`);
+        }
+    }
+    /**
+     * Actually update an extension installed by NPM, using the NPM cli. And update the installation
+     * manifest.
+     *
+     * @param installSpec - name of extension to update
+     * @param version - version string identifier to update extension to
+     */
+    async updateExtension(installSpec, version) {
+        const { pkgName, installType } = this.config.installedExtensions[installSpec];
+        const extData = await this.installViaNpm({
+            installSpec,
+            installType,
+            pkgName,
+            pkgVer: version,
+        });
+        delete extData[`${this.type}Name`];
+        await this.config.updateExtension(installSpec, extData);
+    }
+    /**
+     * Just wraps {@linkcode child_process.spawn} with some default options
+     *
+     * @param cwd - CWD
+     * @param script - Path to script
+     * @param args - Extra args for script
+     * @param opts - Options
+     */
+    _runUnbuffered(cwd, script, args = [], opts = {}) {
+        return (0, node_child_process_1.spawn)(process.execPath, [script, ...args], {
+            cwd,
+            stdio: 'inherit',
+            ...opts,
+        });
+    }
+    /**
+     * Once a package is installed on-disk, this gathers some necessary metadata for validation.
+     *
+     */
+    getInstallationReceipt({ pkg, installPath, installType, installSpec, }) {
+        const { appium, name, version, peerDependencies } = pkg;
+        const strVersion = version;
+        const internal = {
+            pkgName: name,
+            version: strVersion,
+            installType,
+            installSpec,
+            installPath,
+            appiumVersion: peerDependencies?.appium,
+        };
+        const extMetadata = appium;
+        return {
+            ...internal,
+            ...extMetadata,
+        };
+    }
+    /**
+     * Validates the _required_ root fields of an extension's `package.json` file.
+     *
+     * These required fields are:
+     * - `name`
+     * - `version`
+     * - `appium`
+     * @param pkg - `package.json` of extension
+     * @param installSpec - Extension name/spec
+     * @throws {ReferenceError} If `package.json` has a missing or invalid field
+     */
+    validatePackageJson(pkg, installSpec) {
+        const { appium, name, version } = pkg;
+        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 pkg;
+    }
+    /**
+     * Check for available updates for installed extensions
+     *
+     */
+    async _checkForUpdates(listData, showUpdates, lsMsg) {
+        await (0, utils_1.spinWith)(this.isJsonOutput, lsMsg, async () => {
+            // We'd like to still show lsMsg even if showUpdates is false
+            if (!showUpdates) {
+                return;
+            }
+            // Filter to only extensions that need update checks (installed npm packages)
+            const extensionsToCheck = lodash_1.default.toPairs(listData).filter(([, data]) => data.installed && data.installType === extension_config_1.INSTALL_TYPE_NPM);
+            await bluebird_1.default.map(extensionsToCheck, async ([ext, data]) => {
+                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;
+                }
+            }, { concurrency: MAX_CONCURRENT_REPO_FETCHES });
+        });
+    }
+    /**
+     * Add repository URLs to list data for all extensions
+     *
+     */
+    async _addRepositoryUrlsToListData(listData) {
+        await (0, utils_1.spinWith)(this.isJsonOutput, 'Fetching repository information', async () => {
+            await bluebird_1.default.map(lodash_1.default.values(listData), async (data) => {
+                const repoUrl = await this._getRepositoryUrl(data);
+                if (repoUrl) {
+                    data.repositoryUrl = repoUrl;
+                }
+            }, { concurrency: MAX_CONCURRENT_REPO_FETCHES });
+        });
+    }
+    /**
+     * Display normal formatted output
+     *
+     */
+    async _displayNormalListOutput(listData, showUpdates) {
+        for (const [name, data] of lodash_1.default.toPairs(listData)) {
+            const line = await this._formatExtensionLine(name, data, showUpdates);
+            this.log.log(line);
+        }
+        return listData;
+    }
+    /**
+     * Format a single extension line for display
+     *
+     */
+    async _formatExtensionLine(name, data, showUpdates) {
+        if (data.installed) {
+            const installTxt = this._formatInstallText(data);
+            const updateTxt = showUpdates ? this._formatUpdateText(data) : '';
+            return `- ${name.yellow}${installTxt}${updateTxt}`;
+        }
+        const installTxt = ' [not installed]'.grey;
+        return `- ${name.yellow}${installTxt}`;
+    }
+    /**
+     * Format installation status text
+     *
+     */
+    _formatInstallText(data) {
+        const { installType, installSpec, version } = 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)';
+        }
+        return `@${String(version).yellow} ${('[installed ' + typeTxt + ']').green}`;
+    }
+    /**
+     * Format update information text
+     *
+     */
+    _formatUpdateText(data) {
+        const { updateVersion, unsafeUpdateVersion, upToDate, updateError } = data;
+        if (updateError) {
+            return ` [Cannot check for updates: ${updateError}]`.red;
+        }
+        let txt = '';
+        if (updateVersion) {
+            txt += ` [${updateVersion} available]`.magenta;
+        }
+        if (upToDate) {
+            txt += ` [Up to date]`.green;
+        }
+        if (unsafeUpdateVersion) {
+            txt += ` [${unsafeUpdateVersion} available (potentially unsafe)]`.cyan;
+        }
+        return txt;
+    }
+    /**
+     * Get repository URL from package data
+     *
+     */
+    async _getRepositoryUrl(data) {
+        if (data.installed && data.installPath) {
+            return await this._getRepositoryUrlFromInstalled(data);
+        }
+        if (data.pkgName && !data.installed) {
+            return await this._getRepositoryUrlFromNpm(data.pkgName);
+        }
+        return null;
+    }
+    /**
+     * Get repository URL from installed extension's package.json
+     *
+     */
+    async _getRepositoryUrlFromInstalled(data) {
+        try {
+            const pkgJsonPath = node_path_1.default.join(String(data.installPath), 'package.json');
+            if (await support_1.fs.exists(pkgJsonPath)) {
+                const pkg = JSON.parse(await support_1.fs.readFile(pkgJsonPath, 'utf8'));
+                if (pkg.repository) {
+                    if (typeof pkg.repository === 'string') {
+                        return pkg.repository;
+                    }
+                    if (pkg.repository.url) {
+                        return pkg.repository.url.replace(/^git\+/, '').replace(/\.git$/, '');
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore errors reading package.json
+        }
+        return null;
+    }
+    /**
+     * Get repository URL from npm for a package name
+     *
+     */
+    async _getRepositoryUrlFromNpm(pkgName) {
+        try {
+            const repoInfo = await support_1.npm.getPackageInfo(pkgName, ['repository']);
+            // When requesting only 'repository', npm.getPackageInfo returns the repository object directly
+            if (repoInfo) {
+                if (typeof repoInfo === 'string') {
+                    return repoInfo;
+                }
+                if (repoInfo.url) {
+                    return repoInfo.url.replace(/^git\+/, '').replace(/\.git$/, '');
+                }
+            }
+        }
+        catch {
+            // Ignore errors fetching from npm
+        }
+        return null;
+    }
+    /**
+     * Checks whether the given extension is compatible with the currently installed server
+     *
+     */
+    async _checkInstallCompatibility({ installSpec, pkgName, pkgVer, installType, }) {
+        if (extension_config_1.INSTALL_TYPE_NPM !== installType) {
+            return;
+        }
+        await (0, utils_1.spinWith)(this.isJsonOutput, `Checking if '${pkgName}' is compatible`, async () => {
+            const [serverVersion, extVersionRequirement] = await getRemoteExtensionVersionReq(pkgName, pkgVer);
+            if (serverVersion && extVersionRequirement && !semver.satisfies(serverVersion, extVersionRequirement)) {
+                throw this._createFatalError(`'${installSpec}' cannot be installed because the server version it requires (${extVersionRequirement}) ` +
+                    `does not meet the currently installed one (${serverVersion}). Please install ` +
+                    `a compatible server version first.`);
+            }
+        });
+    }
 }
 exports.ExtensionCommand = ExtensionCliCommand;
 /**
  * This is needed to ensure proper module resolution for installed extensions,
  * especially ESM ones.
  *
- * @param {ExtensionConfig<ExtensionType>} driverConfig
- * @param {ExtensionConfig<ExtensionType>} pluginConfig
- * @param {import('@appium/types').AppiumLogger} logger
+ * @param driverConfig - active driver extension config
+ * @param pluginConfig - active plugin extension config
+ * @param logger - logger instance used for non-fatal symlink errors
+ * @returns resolves when symlink injection has completed for all extensions
  */
 async function injectAppiumSymlinks(driverConfig, pluginConfig, logger) {
-    const installPaths = lodash_1.default.compact([
+    const isNpmInstalledExtension = (details) => details.installType === extension_config_1.INSTALL_TYPE_NPM && Boolean(details.installPath);
+    const installedExtensions = [
         ...Object.values(driverConfig.installedExtensions || {}),
-        ...Object.values(pluginConfig.installedExtensions || {})
-    ].filter((details) => details.installType === extension_config_1.INSTALL_TYPE_NPM)
+        ...Object.values(pluginConfig.installedExtensions || {}),
+    ];
+    const installPaths = lodash_1.default.compact(installedExtensions
+        .filter((details) => Boolean(details))
+        .filter(isNpmInstalledExtension)
         .map((details) => details.installPath));
     // After the extension is installed, we try to inject the appium module symlink
     // into the extension's node_modules folder if it is not there yet.
@@ -1030,12 +918,10 @@ async function injectAppiumSymlinks(driverConfig, pluginConfig, logger) {
  * This is needed to ensure proper module resolution for installed extensions,
  * especially ESM ones.
  *
- * @param {string} dstFolder The destination folder where the symlink should be created
- * @param {import('@appium/types').AppiumLogger} logger
- * @returns {Promise<void>}
+ * @param dstFolder The destination folder where the symlink should be created
  */
 async function injectAppiumSymlink(dstFolder, logger) {
-    let appiumModuleRoot;
+    let appiumModuleRoot = '';
     try {
         appiumModuleRoot = (0, utils_2.getAppiumModuleRoot)();
         const symlinkPath = node_path_1.default.join(dstFolder, node_path_1.default.basename(appiumModuleRoot));
@@ -1050,159 +936,4 @@ async function injectAppiumSymlink(dstFolder, logger) {
     }
 }
 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
- * @property {string} [repositoryUrl] - Repository URL for the extension (if available)
- */
-/**
- * @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. If not provided
- * then all available script names will be printed
- * @property {string[]} [extraArgs] - arguments to pass to the script
- * @property {boolean} [bufferOutput] - if true, will buffer the output of the script and return it
- */
-/**
- * Options for {@linkcode ExtensionCliCommand.doctor}.
- * @typedef DoctorOptions
- * @property {string} installSpec - name of the extension to run doctor checks for
- */
-/**
- * Return value of {@linkcode ExtensionCliCommand._run}
- *
- * @typedef RunOutput
- * @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