appium 3.2.2 → 3.3.0

package/lib/cli/extension.ts

@@ -0,0 +1,65 @@
+/* eslint-disable no-console */
+import type {Class, DriverType, ExtensionType, PluginType} from '@appium/types';
+import type {Args, CliExtensionCommand, CliExtensionSubcommand} from 'appium/types';
+import type {ExtensionConfig} from '../extension/extension-config';
+import {DRIVER_TYPE, PLUGIN_TYPE} from '../constants';
+import {isExtensionCommandArgs} from '../utils';
+import DriverCliCommand from './driver-command';
+import PluginCliCommand from './plugin-command';
+import {errAndQuit, JSON_SPACES} from './utils';
+
+export const commandClasses = Object.freeze(
+  {
+    [DRIVER_TYPE]: DriverCliCommand,
+    [PLUGIN_TYPE]: PluginCliCommand,
+  } as const
+);
+
+/**
+ * Executes a driver/plugin extension subcommand and returns the command result.
+ *
+ * When JSON output is enabled, this also prints the serialized command result
+ * unless output was suppressed by the caller.
+ */
+export async function runExtensionCommand<
+  Cmd extends CliExtensionCommand,
+  SubCmd extends CliExtensionSubcommand,
+>(args: Args<Cmd, SubCmd>, config: ExtensionConfig<Cmd>) {
+  // TODO driver config file should be locked while any of these commands are
+  // running to prevent weird situations
+  let jsonResult: Record<string, unknown> = {};
+  const {extensionType: type} = config; // NOTE this is the same as `args.subcommand`
+  if (!isExtensionCommandArgs(args)) {
+    throw new TypeError(`Cannot call ${type} command without a subcommand like 'install'`);
+  }
+  let {json} = args;
+  const {suppressOutput} = args;
+  json = Boolean(json);
+  if (suppressOutput) {
+    json = true;
+  }
+  const CommandClass = commandClasses[type] as ExtCommand<Cmd>;
+  const cmd = new CommandClass({config, json} as any);
+  try {
+    jsonResult = (await cmd.execute(args)) as Record<string, unknown>;
+  } catch (err) {
+    // in the suppress output case, we are calling this function internally and should
+    // just throw instead of printing an error and ending the process
+    if (suppressOutput) {
+      throw err;
+    }
+    errAndQuit(json, err);
+  }
+
+  if (json && !suppressOutput) {
+    console.log(JSON.stringify(jsonResult, null, JSON_SPACES));
+  }
+
+  return jsonResult;
+}
+
+export type ExtCommand<ExtType extends ExtensionType> = ExtType extends DriverType
+  ? Class<DriverCliCommand>
+  : ExtType extends PluginType
+    ? Class<PluginCliCommand>
+    : never;

package/lib/cli/{parser.js → parser.ts}

@@ -1,7 +1,10 @@
 import {fs} from '@appium/support';
 import {ArgumentParser} from 'argparse';
+import type {SubArgumentParserOptions, SubParser} from 'argparse';
 import _ from 'lodash';
 import path from 'node:path';
+import type {DriverType, PluginType} from '@appium/types';
+import type {CliExtensionSubcommand} from 'appium/types';
 import {
   DRIVER_TYPE,
   EXT_SUBCOMMAND_DOCTOR,
@@ -17,6 +20,7 @@ import {
 import {finalizeSchema, getAllArgSpecs, getArgSpec, hasArgSpec} from '../schema';
 import {rootDir} from '../config';
 import {getExtensionArgs, getServerArgs} from './args';
+import type {ArgumentDefinitions} from './args';
 import {
   DEFAULT_PLUGINS,
   SUBCOMMAND_MOBILE,
@@ -38,6 +42,8 @@ const NON_SERVER_ARGS = Object.freeze(
 );
 
 const version = fs.readPackageJsonFrom(rootDir).version;
+type LooseArgsMap = {[key: string]: any};
+type TransformedArgsMap = LooseArgsMap & {[EXTRA_ARGS]: string[]};
 
 /**
  * A wrapper around `argparse`
@@ -46,9 +52,15 @@ const version = fs.readPackageJsonFrom(rootDir).version;
  *    `ArgumentParser` instance for Appium server and its extensions
  * - Handles error conditions, messages, and exit behavior
  */
-class ArgParser {
+export class ArgParser {
+  readonly prog: string;
+  readonly debug: boolean;
+  readonly parser: ArgumentParser;
+  readonly rawArgs: ArgumentDefinitions;
+  readonly parse_args: ArgParser['parseArgs'];
+
   /**
-   * @param {boolean} [debug] - If true, throw instead of exit on error.
+   * @param debug - if true, throw instead of exiting on parse errors
    */
   constructor(debug = false) {
     const prog = process.argv[1] ? path.basename(process.argv[1]) : 'appium';
@@ -62,22 +74,10 @@ class ArgParser {
 
     ArgParser._patchExit(parser);
 
-    /**
-     * Program name (typically `appium`)
-     * @type {string}
-     */
     this.prog = prog;
 
-    /**
-     * If `true`, throw an error on parse failure instead of printing help
-     * @type {boolean}
-     */
     this.debug = debug;
 
-    /**
-     * Wrapped `ArgumentParser` instance
-     * @type {ArgumentParser}
-     */
     this.parser = parser;
 
     parser.add_argument('-v', '--version', {
@@ -101,23 +101,16 @@ class ArgParser {
     ArgParser._addSetupToParser(subParsers);
 
     // backwards compatibility / drop-in wrapper
-    /**
-     * @type {ArgParser['parseArgs']}
-     */
     this.parse_args = this.parseArgs;
   }
 
   /**
-   * Parse arguments from the command line.
-   *
-   * If no subcommand is passed in, this method will inject the `server` subcommand.
+   * Parses CLI args and returns Appium's normalized argument object.
    *
-   * `ArgParser.prototype.parse_args` is an alias of this method.
-   * @template {import('appium/types').CliCommand} [Cmd=import('appium/types').CliCommandServer]
-   * @param {string[]} [args] - Array of arguments, ostensibly from `process.argv`. Gathers args from `process.argv` if not provided.
-   * @returns {import('appium/types').Args<Cmd>} - The parsed arguments
+   * If no explicit subcommand is provided, this injects `server`.
+   * `parse_args` is a backwards-compatible alias of this method.
    */
-  parseArgs(args = process.argv.slice(2)) {
+  parseArgs(args: string[] = process.argv.slice(2)): TransformedArgsMap {
     if (!NON_SERVER_ARGS.has(args[0])) {
       args.unshift(SERVER_SUBCOMMAND);
     }
@@ -159,19 +152,16 @@ class ArgParser {
   }
 
   /**
-   * Normalize hyphenated server arg keys (e.g. "log-level") to dest form (e.g. "loglevel").
-   * Use when server args come from programmatic init rather than the CLI, so they match
-   * the shape produced by parseArgs() / _transformParsedArgs().
-   * Mutates the given object.
+   * Normalizes server arg keys from schema names to parser destination names.
    *
-   * @param {object} obj - Object that may contain server args with schema property names
-   * @returns {object} The same object with keys normalized
+   * This mutates and returns the same object.
    */
-  static normalizeServerArgs(obj) {
+  static normalizeServerArgs<T extends LooseArgsMap>(obj: T): T {
+    const mutableObj = obj as LooseArgsMap;
     for (const spec of getAllArgSpecs().values()) {
-      if (!spec.extType && obj[spec.name] !== undefined && spec.rawDest !== spec.name) {
-        obj[spec.rawDest] = obj[spec.name] ?? obj[spec.rawDest];
-        delete obj[spec.name];
+      if (!spec.extType && mutableObj[spec.name] !== undefined && spec.rawDest !== spec.name) {
+        mutableObj[spec.rawDest] = mutableObj[spec.name] ?? mutableObj[spec.rawDest];
+        delete mutableObj[spec.name];
       }
     }
     return obj;
@@ -183,16 +173,17 @@ class ArgParser {
    * keys to match the intended destination.
    *
    * E.g., `{'driver-foo-bar': baz}` becomes `{driver: {foo: {bar: 'baz'}}}`
-   * @param {object} args
-   * @param {string[]} [unknownArgs]
-   * @returns {object}
    */
-  static _transformParsedArgs(args, unknownArgs = []) {
+  private static _transformParsedArgs(
+    args: LooseArgsMap,
+    unknownArgs: string[] = []
+  ): TransformedArgsMap {
     const result = _.reduce(
       args,
       (unpacked, value, key) => {
-        if (!_.isUndefined(value) && hasArgSpec(key)) {
-          const {dest} = /** @type {import('../schema/arg-spec').ArgSpec} */ (getArgSpec(key));
+        const spec = hasArgSpec(key) ? getArgSpec(key) : undefined;
+        if (!_.isUndefined(value) && spec) {
+          const {dest} = spec;
           _.set(unpacked, dest, value);
         } else {
           // this could be anything that _isn't_ a server arg
@@ -203,14 +194,13 @@ class ArgParser {
       {}
     );
     result[EXTRA_ARGS] = unknownArgs;
-    return result;
+    return result as TransformedArgsMap;
   }
 
   /**
    * Patches the `exit()` method of the parser to throw an error, so we can handle it manually.
-   * @param {ArgumentParser} parser
    */
-  static _patchExit(parser) {
+  private static _patchExit(parser: ArgumentParser): void {
     parser.exit = (code, msg) => {
       if (code) {
         throw new Error(msg);
@@ -220,11 +210,9 @@ class ArgParser {
   }
 
   /**
-   *
-   * @param {import('argparse').SubParser} subParser
-   * @returns {import('./args').ArgumentDefinitions}
+   * Adds the `server` subcommand parser and returns its argument definitions.
    */
-  static _addServerToParser(subParser) {
+  private static _addServerToParser(subParser: SubParser): ArgumentDefinitions {
     const serverParser = subParser.add_parser('server', {
       add_help: true,
       help: 'Start an Appium server',
@@ -244,11 +232,10 @@ class ArgParser {
 
   /**
    * Adds extension sub-sub-commands to `driver`/`plugin` subcommands
-   * @param {import('argparse').SubParser} subParsers
    */
-  static _addExtensionCommandsToParser(subParsers) {
-    for (const type of /** @type {[DriverType, PluginType]} */ ([DRIVER_TYPE, PLUGIN_TYPE])) {
-      const extParser = subParsers.add_parser(type, {
+  private static _addExtensionCommandsToParser(subParser: SubParser): void {
+    for (const type of [DRIVER_TYPE, PLUGIN_TYPE] as [DriverType, PluginType]) {
+      const extParser = subParser.add_parser(type, {
         add_help: true,
         help: `Manage Appium ${type}s`,
         description: `Manage Appium ${type}s using various subcommands`,
@@ -260,10 +247,12 @@ class ArgParser {
         dest: `${type}Command`,
       });
       const extensionArgs = getExtensionArgs();
-      /**
-       * @type { {command: import('appium/types').CliExtensionSubcommand, args: import('./args').ArgumentDefinitions, help: string, aliases?: import('argparse').SubArgumentParserOptions['aliases']}[] }
-       */
-      const parserSpecs = [
+      const parserSpecs: {
+        command: CliExtensionSubcommand;
+        args: ArgumentDefinitions;
+        help: string;
+        aliases?: SubArgumentParserOptions['aliases'];
+      }[] = [
         {
           command: EXT_SUBCOMMAND_LIST,
           args: extensionArgs[type].list,
@@ -316,9 +305,8 @@ class ArgParser {
 
   /**
    * Add subcommand and sub-sub commands for 'setup' subcommand.
-   * @param {import('argparse').SubParser} subParser
    */
-  static _addSetupToParser(subParser) {
+  private static _addSetupToParser(subParser: SubParser): void {
     const setupParser = subParser.add_parser('setup', {
       add_help: true,
       help: 'Batch install or uninstall Appium drivers and plugins',
@@ -368,21 +356,10 @@ class ArgParser {
 }
 
 /**
- * Creates a {@link ArgParser} instance; finalizes the config schema.
- *
- * @constructs ArgParser
- * @param {boolean} [debug] - If `true`, throw instead of exit upon parsing error
- * @returns {ArgParser}
+ * Creates and returns an `ArgParser` after finalizing schema state.
  */
-function getParser(debug) {
+export function getParser(debug = false) {
   finalizeSchema();
 
   return new ArgParser(debug);
 }
-
-export {getParser, ArgParser};
-
-/**
- * @typedef {import('@appium/types').DriverType} DriverType
- * @typedef {import('@appium/types').PluginType} PluginType
- */

package/lib/cli/plugin-command.ts

@@ -0,0 +1,117 @@
+import _ from 'lodash';
+import type {ExtMetadata, ExtRecord, InstallType} from 'appium/types';
+import ExtensionCliCommand from './extension-command';
+import type {
+  ExtensionArgs,
+  ExtensionCommandOptions,
+  ExtensionUpdateResult,
+  PostInstallText,
+  RunOutput,
+} from './extension-command';
+import {KNOWN_PLUGINS} from '../constants';
+
+const REQ_PLUGIN_FIELDS = ['pluginName', 'mainClass'];
+type PluginInstallOpts = {plugin: string; installType: InstallType; packageName?: string};
+type PluginUninstallOpts = {plugin: string};
+type PluginUpdateOpts = {plugin: string; unsafe: boolean};
+type PluginRunOptions = {plugin: string; scriptName: string; extraArgs?: string[]};
+type PluginDoctorOptions = {plugin: string};
+
+export default class PluginCliCommand extends ExtensionCliCommand<'plugin'> {
+  constructor({config, json}: ExtensionCommandOptions<'plugin'>) {
+    super({config, json});
+    this.knownExtensions = KNOWN_PLUGINS;
+  }
+
+  /**
+   * Install a plugin
+   *
+   * @param opts - install options
+   */
+  async install({plugin, installType, packageName}: PluginInstallOpts): Promise<ExtRecord<'plugin'>> {
+    return await super._install({
+      installSpec: plugin,
+      installType,
+      packageName,
+    });
+  }
+
+  /**
+   * Uninstall a plugin
+   *
+   * @param opts - uninstall options
+   */
+  async uninstall({plugin}: PluginUninstallOpts): Promise<ExtRecord<'plugin'>> {
+    return await super._uninstall({installSpec: plugin});
+  }
+
+  /**
+   * Update a plugin
+   *
+   * @param opts - update options
+   */
+  async update({plugin, unsafe}: PluginUpdateOpts): Promise<ExtensionUpdateResult> {
+    return await super._update({installSpec: plugin, unsafe});
+  }
+
+  /**
+   * Run a script from a plugin
+   *
+   * @param opts - script execution options
+   * @throws {Error} if the script fails to run
+   */
+  async run({plugin, scriptName, extraArgs}: PluginRunOptions): Promise<RunOutput> {
+    return await super._run({
+      installSpec: plugin,
+      scriptName,
+      extraArgs,
+      bufferOutput: this.isJsonOutput,
+    });
+  }
+
+  /**
+   * Runs doctor checks for the given plugin
+   *
+   * @param opts - doctor command options
+   * @returns The amount of executed doctor checks.
+   * @throws {Error} If any of the mandatory Doctor checks fails.
+   */
+  async doctor({plugin}: PluginDoctorOptions): Promise<number> {
+    return await super._doctor({
+      installSpec: plugin,
+    });
+  }
+
+  /**
+   * Builds the success message displayed after a plugin installation.
+   *
+   * @param args - installed extension name and metadata
+   * @returns formatted success text
+   */
+  override getPostInstallText({extName, extData}: ExtensionArgs<'plugin'>): PostInstallText {
+    return `Plugin ${extName}@${extData.version} successfully installed`.green;
+  }
+
+  /**
+   * Validates fields in `appium` field of `pluginMetadata`
+   *
+   * For any `package.json` fields which a plugin requires, validate the type of
+   * those fields on the `package.json` data, throwing an error if anything is
+   * amiss.
+   * @param pluginMetadata - `appium` metadata from extension package
+   * @param installSpec - install spec from CLI
+   */
+  override validateExtensionFields(pluginMetadata: ExtMetadata<'plugin'>, installSpec: string): void {
+    const missingFields = REQ_PLUGIN_FIELDS.reduce(
+      (acc, field) => (pluginMetadata[field] ? acc : [...acc, field]),
+      []
+    );
+
+    if (!_.isEmpty(missingFields)) {
+      throw new Error(
+        `Installed plugin "${installSpec}" did not expose correct fields for compatibility ` +
+          `with Appium. Missing fields: ${JSON.stringify(missingFields)}`
+      );
+    }
+  }
+}

package/lib/cli/{setup-command.js → setup-command.ts}

@@ -1,4 +1,11 @@
 import _ from 'lodash';
+import type {
+  Args,
+  CliCommandSetup,
+  CliCommandSetupSubcommand,
+  CliExtensionCommand,
+  CliExtensionSubcommand,
+} from 'appium/types';
 import {
   DESKTOP_BROWSERS,
   DESKTOP_DRIVERS,
@@ -7,6 +14,7 @@ import {
 import {runExtensionCommand} from './extension';
 import { system, fs } from '@appium/support';
 import log from '../logger';
+import type {ExtensionConfig} from '../extension/extension-config';
 
 /**
  * Subcommands of preset for setup
@@ -20,13 +28,11 @@ export const SUBCOMMAND_RESET = 'reset';
  * Pairs of preset subcommand and driver candidates.
  * Driver names listed in KNOWN_DRIVERS to install by default
  */
-const PRESET_PAIRS = Object.freeze(
-  /** @type {const} */ ({
-    mobile: _.keys(MOBILE_DRIVERS),
-    desktop: _.keys(DESKTOP_DRIVERS),
-    browser: _.keys(DESKTOP_BROWSERS)
-  }),
-);
+const PRESET_PAIRS = Object.freeze({
+  mobile: _.keys(MOBILE_DRIVERS),
+  desktop: _.keys(DESKTOP_DRIVERS),
+  browser: _.keys(DESKTOP_BROWSERS),
+} as const);
 const DRIVERS_ONLY_MACOS = ['xcuitest', 'safari', 'mac2'];
 
 const DRIVERS_ONLY_WINDOWS = ['windows'];
@@ -36,12 +42,14 @@ const DRIVERS_ONLY_WINDOWS = ['windows'];
  */
 export const DEFAULT_PLUGINS = ['images', 'inspector'];
 
+type DriverConfig = ExtensionConfig<'driver'>;
+type PluginConfig = ExtensionConfig<'plugin'>;
+type CliExtArgs = Args<CliExtensionCommand, CliExtensionSubcommand>;
+
 /**
  * Return a list of drivers available for current host platform.
- * @param {import('appium/types').CliCommandSetupSubcommand} presetName
- * @returns {Array<string>}
  */
-export function getPresetDrivers(presetName) {
+export function getPresetDrivers(presetName: CliCommandSetupSubcommand): string[] {
   return _.filter(PRESET_PAIRS[presetName], (driver) => {
     if (_.includes(DRIVERS_ONLY_MACOS, driver)) {
       return system.isMac();
@@ -58,9 +66,8 @@ export function getPresetDrivers(presetName) {
 
 /**
  * Return desktop platform name for setup command description.
- * @returns {string}
  */
-export function determinePlatformName() {
+export function determinePlatformName(): string {
   if (system.isMac()) {
     return 'macOS';
   } else if (system.isWindows()) {
@@ -70,14 +77,16 @@ export function determinePlatformName() {
 }
 
 /**
- * Run 'setup' command to install drivers/plugins into the given appium home.
- * @template {import('appium/types').CliCommandSetup} SetupCmd
- * @param {import('appium/types').Args<SetupCmd>} preConfigArgs
- * @param {DriverConfig} driverConfig
- * @param {PluginConfig} pluginConfig
- * @returns {Promise<void>}
- */
-export async function runSetupCommand(preConfigArgs, driverConfig, pluginConfig) {
+ * Runs the `setup` command and applies the selected preset.
+ *
+ * Depending on the subcommand, this installs mobile/desktop/browser presets or
+ * removes all installed extensions and manifests via `reset`.
+ */
+export async function runSetupCommand(
+  preConfigArgs: Args<CliCommandSetup>,
+  driverConfig: DriverConfig,
+  pluginConfig: PluginConfig
+): Promise<void> {
   switch (preConfigArgs.setupCommand) {
     case SUBCOMMAND_DESKTOP:
       await setupDesktopAppDrivers(driverConfig);
@@ -99,22 +108,19 @@ export async function runSetupCommand(preConfigArgs, driverConfig, pluginConfig)
 
 /**
  * Resets all installed drivers and extensions
- *
- * @param {DriverConfig} driverConfig
- * @param {PluginConfig} pluginConfig
- * @returns {Promise<void>}
  */
-async function resetAllExtensions(driverConfig, pluginConfig) {
-  for (const [command, config] of [
+async function resetAllExtensions(driverConfig: DriverConfig, pluginConfig: PluginConfig): Promise<void> {
+  const commandConfigs: [CliExtensionCommand, DriverConfig | PluginConfig][] = [
     ['driver', driverConfig],
     ['plugin', pluginConfig],
-  ]) {
-    for (const extensionName of _.keys(/** @type {DriverConfig|PluginConfig} */ (config).installedExtensions)) {
+  ];
+  for (const [command, config] of commandConfigs) {
+    for (const extensionName of _.keys(config.installedExtensions)) {
       try {
         await uninstallExtension(
           extensionName,
-          extensionCommandArgs(/** @type {CliExtensionCommand} */ (command), extensionName, 'uninstall'),
-          /** @type {DriverConfig|PluginConfig} */ (config)
+          extensionCommandArgs(command, extensionName, 'uninstall'),
+          config
         );
       } catch (e) {
         log.warn(
@@ -124,7 +130,7 @@ async function resetAllExtensions(driverConfig, pluginConfig) {
       }
     }
 
-    const manifestPath = /** @type {DriverConfig|PluginConfig} */ (config).manifestPath;
+    const manifestPath = config.manifestPath;
     if (!await fs.exists(manifestPath)) {
       continue;
     }
@@ -140,38 +146,29 @@ async function resetAllExtensions(driverConfig, pluginConfig) {
 
 /**
  * Install drivers listed in DEFAULT_DRIVERS.
- * @param {DriverConfig} driverConfig
- * @returns {Promise<void>}
  */
-async function setupMobileDrivers(driverConfig) {
+async function setupMobileDrivers(driverConfig: DriverConfig): Promise<void> {
   await installDrivers(SUBCOMMAND_MOBILE, driverConfig);
 }
 
 /**
  * Install all of known drivers listed in BROWSER_DRIVERS.
- * @param {DriverConfig} driverConfig
- * @returns {Promise<void>}
  */
-async function setupBrowserDrivers(driverConfig) {
+async function setupBrowserDrivers(driverConfig: DriverConfig): Promise<void> {
   await installDrivers(SUBCOMMAND_BROWSER, driverConfig);
 }
 
 /**
  * Install all of known drivers listed in DESKTOP_APP_DRIVERS.
- * @param {DriverConfig} driverConfig
- * @returns {Promise<void>}
  */
-async function setupDesktopAppDrivers(driverConfig) {
+async function setupDesktopAppDrivers(driverConfig: DriverConfig): Promise<void> {
   await installDrivers(SUBCOMMAND_DESKTOP, driverConfig);
 }
 
 /**
  * Install the given driver name. It skips the installation if the given driver name was already installed.
- * @param {import('appium/types').CliCommandSetupSubcommand} subcommand
- * @param {DriverConfig} driverConfig
- * @returns {Promise<void>}
  */
-async function installDrivers(subcommand, driverConfig) {
+async function installDrivers(subcommand: CliCommandSetupSubcommand, driverConfig: DriverConfig): Promise<void> {
   for (const driverName of getPresetDrivers(subcommand)) {
     await installExtension(driverName, extensionCommandArgs('driver', driverName, 'install'), driverConfig);
   }
@@ -179,10 +176,8 @@ async function installDrivers(subcommand, driverConfig) {
 
 /**
  * Install plugins listed in DEFAULT_PLUGINS.
- * @param {PluginConfig} pluginConfig
- * @returns {Promise<void>}
  */
-async function setupDefaultPlugins(pluginConfig) {
+async function setupDefaultPlugins(pluginConfig: PluginConfig): Promise<void> {
   for (const pluginName of DEFAULT_PLUGINS) {
     await installExtension(pluginName, extensionCommandArgs('plugin', pluginName, 'install'), pluginConfig);
   }
@@ -190,12 +185,12 @@ async function setupDefaultPlugins(pluginConfig) {
 
 /**
  * Run the given extensionConfigArgs command after checking if the given extensionName was already installed.
- * @param {string} extensionName
- * @param {Args} extensionConfigArgs
- * @param {DriverConfig|PluginConfig} extensionConfig
- * @returns {Promise<void>}
  */
-async function installExtension(extensionName, extensionConfigArgs, extensionConfig) {
+async function installExtension(
+  extensionName: string,
+  extensionConfigArgs: CliExtArgs,
+  extensionConfig: DriverConfig | PluginConfig
+): Promise<void> {
   if (_.keys(extensionConfig.installedExtensions).includes(extensionName)) {
     log.info(`${extensionName} (${extensionConfig.installedExtensions[extensionName].version}) is already installed. ` +
       `Skipping the installation.`);
@@ -206,12 +201,12 @@ async function installExtension(extensionName, extensionConfigArgs, extensionCon
 
 /**
  * Run the given extensionConfigArgs command after checking if the given extensionName was already installed.
- * @param {string} extensionName
- * @param {Args} extensionConfigArgs
- * @param {DriverConfig|PluginConfig} extensionConfig
- * @returns {Promise<void>}
  */
-async function uninstallExtension(extensionName, extensionConfigArgs, extensionConfig) {
+async function uninstallExtension(
+  extensionName: string,
+  extensionConfigArgs: CliExtArgs,
+  extensionConfig: DriverConfig | PluginConfig
+): Promise<void> {
   if (!_.keys(extensionConfig.installedExtensions).includes(extensionName)) {
     log.info(`${extensionName} (${extensionConfig.installedExtensions[extensionName].version}) is not installed. ` +
       `Skipping its uninstall.`);
@@ -222,24 +217,14 @@ async function uninstallExtension(extensionName, extensionConfigArgs, extensionC
 
 /**
  * Return the command config for driver or plugin.
- * @param {CliExtensionCommand} extensionCommand
- * @param {string} extensionName
- * @param {CliExtensionSubcommand} command
- * @returns {Args}
  */
-function extensionCommandArgs(extensionCommand, extensionName, command) {
+function extensionCommandArgs(
+  extensionCommand: CliExtensionCommand,
+  extensionName: string,
+  command: CliExtensionSubcommand
+): CliExtArgs {
   return (extensionCommand === 'plugin')
     ? {'subcommand': 'plugin', 'pluginCommand': command, 'plugin': extensionName}
     : {'subcommand': 'driver', 'driverCommand': command, 'driver': extensionName};
 }
 
-/**
- * @typedef {import('appium/types').CliExtensionCommand} CliExtensionCommand
- * @typedef {import('appium/types').CliExtensionSubcommand} CliExtensionSubcommand
- * @typedef {import('../extension/extension-config').ExtensionConfig<CliExtensionCommand>} PluginConfig
- * @typedef {import('../extension/extension-config').ExtensionConfig<CliExtensionCommand>} DriverConfig
- */
-
-/**
- * @typedef {import('appium/types').Args<CliExtensionCommand, CliExtensionSubcommand>} Args
- */