appium 3.4.2 → 3.5.1

package/lib/cli/extension-command.ts

@@ -1,6 +1,6 @@
-import B from 'bluebird';
-import _ from 'lodash';
+import {asyncfilter, asyncmap} from 'asyncbox';
 import path from 'node:path';
+import {console, env, fs, npm, system, util} from '@appium/support';
 import type {AppiumLogger, ExtensionType, IDoctorCheck} from '@appium/types';
 import type {
   ExtInstallReceipt as AppiumExtInstallReceipt,
@@ -12,7 +12,6 @@ import type {
 } from 'appium/types';
 import type {PackageJson} from 'type-fest';
 import type {ExtensionConfig as BaseExtensionConfig} from '../extension/extension-config';
-import {npm, util, env, console, fs, system} from '@appium/support';
 import {spinWith, RingBuffer} from './utils';
 import {
   INSTALL_TYPE_NPM,
@@ -22,12 +21,11 @@ import {
   INSTALL_TYPE_DEV,
 } from '../extension/extension-config';
 import {SubProcess} from 'teen_process';
-import {packageDidChange} from '../extension/package-changed';
 import {spawn} from 'node:child_process';
 import {inspect} from 'node:util';
 import {pathToFileURL} from 'node:url';
 import {Doctor, EXIT_CODE as DOCTOR_EXIT_CODE} from '../doctor/doctor';
-import {getAppiumModuleRoot, npmPackage} from '../utils';
+import {appiumPackageRoot, compact, npmPackage, packageDidChange} from '../utils';
 import * as semver from 'semver';
 
 const UPDATE_ALL = 'installed';
@@ -40,13 +38,15 @@ export type ExtensionCommandOptions<ExtType extends ExtensionType = ExtensionTyp
   config: ExtensionConfig<ExtType>;
   json: boolean;
 };
-export type ExtensionConfig<ExtType extends ExtensionType = ExtensionType> = BaseExtensionConfig<ExtType>;
+export type ExtensionConfig<ExtType extends ExtensionType = ExtensionType> =
+  BaseExtensionConfig<ExtType>;
 
 export type ExtRecord<ExtType extends ExtensionType = ExtensionType> = AppiumExtRecord<ExtType>;
 
 export type ExtMetadata<ExtType extends ExtensionType = ExtensionType> = AppiumExtMetadata<ExtType>;
 export type ExtManifest<ExtType extends ExtensionType = ExtensionType> = AppiumExtManifest<ExtType>;
-export type ExtPackageJson<ExtType extends ExtensionType = ExtensionType> = AppiumExtPackageJson<ExtType>;
+export type ExtPackageJson<ExtType extends ExtensionType = ExtensionType> =
+  AppiumExtPackageJson<ExtType>;
 export type ExtInstallReceipt<ExtType extends ExtensionType = ExtensionType> =
   AppiumExtInstallReceipt<ExtType>;
 /**
@@ -69,8 +69,8 @@ export type ExtensionListData<ExtType extends ExtensionType = ExtensionType> = P
 > &
   Partial<ExtensionListMetadata>;
 
-export type InstalledExtensionListData<ExtType extends ExtensionType = ExtensionType> = ExtManifest<ExtType> &
-  ExtensionListMetadata;
+export type InstalledExtensionListData<ExtType extends ExtensionType = ExtensionType> =
+  ExtManifest<ExtType> & ExtensionListMetadata;
 
 /**
  * Return value of {@linkcode ExtensionCliCommand.list}.
@@ -93,7 +93,10 @@ export type PostInstallText = string;
 /**
  * Return value of {@linkcode ExtensionCliCommand._update}.
  */
-export type ExtensionUpdateResult = {errors: Record<string, Error>; updates: Record<string, UpdateReport>};
+export type ExtensionUpdateResult = {
+  errors: Record<string, Error>;
+  updates: Record<string, UpdateReport>;
+};
 
 /**
  * Used by {@linkcode ExtensionCliCommand.getPostInstallText}
@@ -177,7 +180,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
   /**
    * {@linkcode Record} of official plugins or drivers.
    */
-  protected knownExtensions: Record<string, string>;
+  protected knownExtensions!: Record<string, string>;
 
   /**
    * If `true`, command output has been requested as JSON.
@@ -210,12 +213,12 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
    * @returns result of the executed extension subcommand
    */
   async execute(args: Record<string, any>): Promise<unknown> {
-    const cmd = args[`${this.type}Command`];
-    if (!_.isFunction(this[cmd])) {
+    const cmd = args[`${this.type}Command`] as string;
+    const handler = (this as Record<string, unknown>)[cmd];
+    if (typeof handler !== 'function') {
       throw this._createFatalError(`Cannot handle ${this.type} command ${cmd}`);
     }
-    const executeCmd = this[cmd].bind(this);
-    return await executeCmd(args);
+    return await handler.call(this, args);
   }
 
   /**
@@ -263,7 +266,11 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
    * Build the initial list data structure from installed and known extensions
    *
    */
-  protected async _install({installSpec, installType, packageName}: InstallOpts): Promise<Record<string, any>> {
+  protected async _install({
+    installSpec,
+    installType,
+    packageName,
+  }: InstallOpts): Promise<Record<string, any>> {
     if (packageName && [INSTALL_TYPE_LOCAL, INSTALL_TYPE_NPM].includes(installType)) {
       throw this._createFatalError(`When using --source=${installType}, cannot also use --package`);
     }
@@ -286,7 +293,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
       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>'
+            'it should be of the form <org>/<repo>',
         );
       }
       installViaNpmOpts = {
@@ -335,7 +342,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
           // dereference the actual npm package ('appiupm-xcuitest-driver'), so
           // check it exists and get the correct package
           const knownNames = Object.keys(this.knownExtensions);
-          if (!_.includes(knownNames, name)) {
+          if (!knownNames.includes(name)) {
             const msg =
               `Could not resolve ${this.type}; are you sure it's in the list ` +
               `of supported ${this.type}s? ${JSON.stringify(knownNames)}`;
@@ -356,7 +363,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
       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".`
+          `installed ${this.type}s with "appium ${this.type} list --installed".`,
       );
     }
 
@@ -366,14 +373,17 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
 
     // this _should_ be the same as `probablyExtName` as the one derived above unless
     // install type is local.
-    const extName = receipt[`${this.type}Name`];
+    const extName =
+      this.type === 'driver'
+        ? (receipt as ExtInstallReceipt<'driver'>).driverName
+        : (receipt as ExtInstallReceipt<'plugin'>).pluginName;
 
     // 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".`
+          `installed ${this.type}s with "appium ${this.type} list --installed".`,
       );
     }
 
@@ -381,7 +391,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
     // so that's why it's being removed here.
     const extManifest = receiptToManifest(receipt);
 
-    const [errors, warnings] = await B.all([
+    const [errors, warnings] = await Promise.all([
       this.config.getProblems(extName, extManifest as any),
       this.config.getWarnings(extName, extManifest as any),
     ]);
@@ -389,15 +399,15 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
     const warningMap = new Map([[extName, warnings]]);
     const {errorSummaries, warningSummaries} = this.config.getValidationResultSummaries(
       errorMap,
-      warningMap
+      warningMap,
     );
 
-    if (!_.isEmpty(errorSummaries)) {
+    if (!util.isEmpty(errorSummaries)) {
       throw this._createFatalError(errorSummaries.join('\n'));
     }
 
     // note that we won't show any warnings if there were errors.
-    if (!_.isEmpty(warningSummaries)) {
+    if (!util.isEmpty(warningSummaries)) {
       this.log.warn(warningSummaries.join('\n'));
     }
 
@@ -410,7 +420,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
 
     // log info for the user
     this.log.info(
-      this.getPostInstallText({extName, extData: receipt as unknown as ExtInstallReceipt<ExtType>})
+      this.getPostInstallText({extName, extData: receipt as unknown as ExtInstallReceipt<ExtType>}),
     );
 
     return this.config.installedExtensions;
@@ -428,7 +438,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
   protected async _uninstall({installSpec}: UninstallOpts): Promise<Record<string, any>> {
     if (!this.config.isInstalled(installSpec)) {
       throw this._createFatalError(
-        `Can't uninstall ${this.type} '${installSpec}'; it is not installed`
+        `Can't uninstall ${this.type} '${installSpec}'; it is not installed`,
       );
     }
     const extRecord = this.config.installedExtensions[installSpec];
@@ -441,7 +451,9 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
       await npm.uninstallPackage(this.config.appiumHome, pkgName);
     });
     await this.config.removeExtension(installSpec);
-    this.log.ok(`Successfully uninstalled ${this.type} '${installSpec}'`.green);
+    this.log.ok(
+      console.styleText('green', `Successfully uninstalled ${this.type} '${installSpec}'`),
+    );
     return this.config.installedExtensions;
   }
 
@@ -449,12 +461,15 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
    * Attempt to update one or more drivers using NPM
    *
    */
-  protected async _update({installSpec, unsafe}: ExtensionUpdateOpts): Promise<ExtensionUpdateResult> {
+  protected async _update({
+    installSpec,
+    unsafe,
+  }: ExtensionUpdateOpts): Promise<ExtensionUpdateResult> {
     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`
+        `The ${this.type} "${installSpec}" was not installed, so can't be updated`,
       );
     }
     const extsToUpdate = shouldUpdateAll
@@ -484,13 +499,13 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
               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`
+              `breaking changes. If you want to apply this update, re-run with --unsafe`,
           );
         }
         const updateVer = unsafe && update.unsafeUpdate ? update.unsafeUpdate : update.safeUpdate;
@@ -500,37 +515,43 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
         await spinWith(
           this.isJsonOutput,
           `Updating ${this.type} '${e}' from ${update.current} to ${updateVer}`,
-          async () => await this.updateExtension(e, 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) {
-          const newMajorUpdateMsg = `A newer major version ${update.unsafeUpdate} ` +
+          const newMajorUpdateMsg =
+            `A newer major version ${update.unsafeUpdate} ` +
             `is available for ${this.type} '${e}', which could include breaking changes. ` +
             `If you want to apply this update, re-run with --unsafe`;
-          this.log.info(newMajorUpdateMsg.yellow);
+          this.log.info(console.styleText('yellow', newMajorUpdateMsg));
         }
         updates[e] = {from: update.current, to: updateVer};
       } catch (err) {
-        errors[e] = err;
+        errors[e] = err instanceof Error ? err : new Error(String(err));
       }
     }
 
     this.log.info('Update report:');
 
-    for (const [e, update] of _.toPairs(updates)) {
-      this.log.ok(`  - ${this.type} ${e} updated: ${update.from} => ${update.to}`.green);
+    for (const [e, update] of Object.entries(updates)) {
+      this.log.ok(
+        console.styleText('green', `  - ${this.type} ${e} updated: ${update.from} => ${update.to}`),
+      );
     }
 
-    for (const [e, err] of _.toPairs(errors)) {
+    for (const [e, err] of Object.entries(errors)) {
       if (err instanceof NotUpdatableError) {
         this.log.warn(
-          `  - '${e}' was not installed via npm, so we could not check ` + `for updates`.yellow
+          console.styleText(
+            'yellow',
+            `  - '${e}' was not installed via npm, so we could not check for updates`,
+          ),
         );
       } else if (err instanceof NoUpdatesAvailableError) {
-        this.log.info(`  - '${e}' had no updates available`.yellow);
+        this.log.info(console.styleText('yellow', `  - '${e}' had no updates available`));
       } else {
         // otherwise, make it pop with red!
-        this.log.error(`  - '${e}' failed to update: ${err}`.red);
+        this.log.error(console.styleText('red', `  - '${e}' failed to update: ${err}`));
       }
     }
     return {updates, errors};
@@ -551,7 +572,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
     let safeUpdate = await npm.getLatestSafeUpgradeVersion(
       this.config.appiumHome,
       pkgName,
-      version
+      version,
     );
     if (unsafeUpdate !== null && !util.compareVersions(unsafeUpdate, '>', version)) {
       // the latest version is not greater than the current version, so there's no possible update
@@ -583,41 +604,42 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
 
     const moduleRoot = this.config.getInstallPath(installSpec);
     const packageJsonPath = path.join(moduleRoot, 'package.json');
-    if (!await fs.exists(packageJsonPath)) {
+    if (!(await fs.exists(packageJsonPath))) {
       throw this._createFatalError(
-        `No package.json could be found for "${installSpec}" ${this.type}`
+        `No package.json could be found for "${installSpec}" ${this.type}`,
       );
     }
     let doctorSpec: {checks: string[]} | undefined;
     try {
       doctorSpec = JSON.parse(await fs.readFile(packageJsonPath, 'utf8')).appium?.doctor;
     } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
       throw this._createFatalError(
-        `The manifest at '${packageJsonPath}' cannot be parsed: ${e.message}`
+        `The manifest at '${packageJsonPath}' cannot be parsed: ${message}`,
       );
     }
     if (!doctorSpec) {
       this.log.info(`The ${this.type} "${installSpec}" does not export any doctor checks`);
       return 0;
     }
-    if (!_.isPlainObject(doctorSpec) || !_.isArray(doctorSpec.checks)) {
+    if (!util.isPlainObject(doctorSpec) || !Array.isArray(doctorSpec.checks)) {
       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`
+          `containing the 'checks' key with the array of script paths`,
       );
     }
     const paths: string[] = doctorSpec.checks
       .map((p) => {
-      const scriptPath = path.resolve(moduleRoot, p);
-      if (!path.normalize(scriptPath).startsWith(path.normalize(moduleRoot))) {
-        this.log.error(
-          `The doctor check script '${p}' from the package manifest '${packageJsonPath}' must be located ` +
-          `in the '${moduleRoot}' root folder. It will be skipped`
-        );
-        return null;
-      }
-      return scriptPath;
-    })
+        const scriptPath = path.resolve(moduleRoot, p);
+        if (!path.normalize(scriptPath).startsWith(path.normalize(moduleRoot))) {
+          this.log.error(
+            `The doctor check script '${p}' from the package manifest '${packageJsonPath}' must be located ` +
+              `in the '${moduleRoot}' root folder. It will be skipped`,
+          );
+          return null;
+        }
+        return scriptPath;
+      })
       .filter((p): p is string => Boolean(p));
     const loadChecksPromises: Promise<unknown>[] = [];
     for (const p of paths) {
@@ -627,23 +649,27 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
         try {
           return await import(scriptPath);
         } catch (e) {
-          this.log.warn(`Unable to load doctor checks from '${p}': ${e.message}`);
+          const message = e instanceof Error ? e.message : String(e);
+          this.log.warn(`Unable to load doctor checks from '${p}': ${message}`);
         }
       })();
       loadChecksPromises.push(promise);
     }
-    const isDoctorCheck = (x) =>
-      ['diagnose', 'fix', 'hasAutofix', 'isOptional'].every((method) => _.isFunction(x?.[method]));
-    const checks: IDoctorCheck[] = _.flatMap((await B.all(loadChecksPromises)).filter(Boolean).map(_.toPairs))
-      .map(([, value]) => value)
-      .filter(isDoctorCheck) as IDoctorCheck[];
-    if (_.isEmpty(checks)) {
+    const isDoctorCheck = (x: unknown): x is IDoctorCheck =>
+      ['diagnose', 'fix', 'hasAutofix', 'isOptional'].every(
+        (method) => typeof (x as IDoctorCheck)?.[method as keyof IDoctorCheck] === 'function',
+      );
+    const checks: IDoctorCheck[] = (await Promise.all(loadChecksPromises))
+      .filter((mod): mod is object => Boolean(mod))
+      .flatMap((mod) => Object.values(mod))
+      .filter(isDoctorCheck);
+    if (util.isEmpty(checks)) {
       this.log.info(`The ${this.type} "${installSpec}" exports no valid doctor checks`);
       return 0;
     }
     this.log.debug(
       `Running ${util.pluralize('doctor check', checks.length, true)} ` +
-      `for the "${installSpec}" ${this.type}`
+        `for the "${installSpec}" ${this.type}`,
     );
     const exitCode = await new Doctor(checks).run();
     if (exitCode !== DOCTOR_EXIT_CODE.SUCCESS) {
@@ -677,39 +703,41 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
     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`
+          `"scripts" field underneath the "appium" field in its package.json`,
       );
     }
 
     const extScripts = extConfig.scripts;
 
-    if (!extScripts || !_.isPlainObject(extScripts)) {
+    if (!extScripts || !util.isPlainObject(extScripts)) {
       throw this._createFatalError(
-        `The ${this.type} named '${installSpec}' "scripts" field must be a plain object`
+        `The ${this.type} named '${installSpec}' "scripts" field must be a plain object`,
       );
     }
 
     if (!scriptName) {
-      const allScripts = _.toPairs(extScripts as Record<string, string>);
+      const allScripts = Object.entries(extScripts as Record<string, string>);
       const root = this.config.getInstallPath(installSpec);
-      const existingScripts = await B.filter(
+      const existingScripts = await asyncfilter(
         allScripts,
-        async ([, p]) => await fs.exists(path.join(root, p))
+        async ([, p]) => await fs.exists(path.join(root, p)),
       );
-      if (_.isEmpty(existingScripts)) {
+      if (util.isEmpty(existingScripts)) {
         this.log.info(`The ${this.type} named '${installSpec}' does not contain any scripts`);
       } else {
-        this.log.info(`The ${this.type} named '${installSpec}' contains ` +
-          `${util.pluralize('script', existingScripts.length, true)}:`);
+        this.log.info(
+          `The ${this.type} named '${installSpec}' contains ` +
+            `${util.pluralize('script', existingScripts.length, true)}:`,
+        );
         existingScripts.forEach(([name]) => this.log.info(`  - ${name}`));
       }
-      this.log.ok(`Successfully retrieved the list of scripts`.green);
+      this.log.ok(console.styleText('green', 'Successfully retrieved the list of scripts'));
       return {};
     }
 
     if (!(scriptName in extScripts)) {
       throw this._createFatalError(
-        `The ${this.type} named '${installSpec}' does not support the script: '${scriptName}'`
+        `The ${this.type} named '${installSpec}' does not support the script: '${scriptName}'`,
       );
     }
 
@@ -718,7 +746,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
     const normalizedScriptPath = path.normalize(path.resolve(moduleRoot, scriptPath));
     if (!normalizedScriptPath.startsWith(path.normalize(moduleRoot))) {
       throw this._createFatalError(
-        `The '${scriptPath}' script must be located in the '${moduleRoot}' folder`
+        `The '${scriptPath}' script must be located in the '${moduleRoot}' folder`,
       );
     }
 
@@ -738,16 +766,17 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
 
       try {
         await runner.join();
-        this.log.ok(`${scriptName} successfully ran`.green);
+        this.log.ok(console.styleText('green', `${scriptName} successfully ran`));
         return {output: output.getBuff()};
       } catch (err) {
-        const message = `Encountered an error when running '${scriptName}': ${err.message}`;
+        const errMessage = err instanceof Error ? err.message : String(err);
+        const message = `Encountered an error when running '${scriptName}': ${errMessage}`;
         throw this._createFatalError(message);
       }
     }
 
     try {
-      await new B((resolve, reject) => {
+      await new Promise<void>((resolve, reject) => {
         this._runUnbuffered(moduleRoot, scriptPath, extraArgs)
           .once('error', (err) => {
             // generally this is of the "I can't find the script" variety.
@@ -763,10 +792,11 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
             }
           });
       });
-      this.log.ok(`${scriptName} successfully ran`.green);
+      this.log.ok(console.styleText('green', `${scriptName} successfully ran`));
       return {};
     } catch (err) {
-      const message = `Encountered an error when running '${scriptName}': ${err.message}`;
+      const errMessage = err instanceof Error ? err.message : String(err);
+      const message = `Encountered an error when running '${scriptName}': ${errMessage}`;
       throw this._createFatalError(message);
     }
   }
@@ -774,7 +804,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
   private _buildListData(showInstalled: boolean): ExtensionList {
     const installedNames = Object.keys(this.config.installedExtensions);
     const knownNames = Object.keys(this.knownExtensions);
-    return [...installedNames, ...knownNames].reduce((acc, name) => {
+    return [...installedNames, ...knownNames].reduce<ExtensionList>((acc, name) => {
       if (!acc[name]) {
         if (installedNames.includes(name)) {
           acc[name] = {
@@ -807,17 +837,18 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
 
     // 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 === INSTALL_TYPE_NPM ? `${pkgName}${pkgVer ? `@${pkgVer}` : ''}` : installSpec;
+    const installStr =
+      installType === INSTALL_TYPE_NPM ? `${pkgName}${pkgVer ? `@${pkgVer}` : ''}` : installSpec;
     const appiumHome = this.config.appiumHome;
     try {
       const {pkg, installPath} = await spinWith(
         this.isJsonOutput,
         installMsg,
-        async () => await npm.installPackage(appiumHome, installStr, {pkgName, installType})
+        async () => await npm.installPackage(appiumHome, installStr, {pkgName, installType}),
       );
 
       const validatedPkg = await spinWith(this.isJsonOutput, validateMsg, async () =>
-        this.validatePackageJson(pkg, installSpec)
+        this.validatePackageJson(pkg, installSpec),
       );
 
       return this.getInstallationReceipt({
@@ -827,11 +858,11 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
         installSpec,
       });
     } catch (err) {
-      throw this._createFatalError(`Encountered an error when installing package: ${err.message}`);
+      const message = err instanceof Error ? err.message : String(err);
+      throw this._createFatalError(`Encountered an error when installing package: ${message}`);
     }
   }
 
-
   /**
    * Actually update an extension installed by NPM, using the NPM cli. And update the installation
    * manifest.
@@ -848,8 +879,17 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
       pkgVer: version,
     });
 
-    delete extData[`${this.type}Name`];
-    await this.config.updateExtension(installSpec, extData as any);
+    const extManifest =
+      this.type === 'driver'
+        ? (({driverName, ...rest}) => {
+            void driverName;
+            return rest;
+          })(extData as ExtInstallReceipt<'driver'>)
+        : (({pluginName, ...rest}) => {
+            void pluginName;
+            return rest;
+          })(extData as ExtInstallReceipt<'plugin'>);
+    await this.config.updateExtension(installSpec, extManifest as any);
   }
 
   /**
@@ -864,7 +904,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
     cwd: string,
     script: string,
     args: string[] = [],
-    opts: Record<string, any> = {}
+    opts: Record<string, any> = {},
   ) {
     return spawn(process.execPath, [script, ...args], {
       cwd,
@@ -919,7 +959,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
 
     const createMissingFieldError = (field: string): ReferenceError =>
       new ReferenceError(
-        `${this.type} "${installSpec}" invalid; missing a \`${field}\` field of its \`package.json\``
+        `${this.type} "${installSpec}" invalid; missing a \`${field}\` field of its \`package.json\``,
       );
 
     if (!name) {
@@ -944,7 +984,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
   private async _checkForUpdates(
     listData: ExtensionList,
     showUpdates: boolean,
-    lsMsg: string
+    lsMsg: string,
   ): Promise<void> {
     await spinWith(this.isJsonOutput, lsMsg, async () => {
       // We'd like to still show lsMsg even if showUpdates is false
@@ -953,11 +993,11 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
       }
 
       // Filter to only extensions that need update checks (installed npm packages)
-      const extensionsToCheck = _.toPairs(listData as Record<string, any>).filter(
-        ([, data]) => data.installed && data.installType === INSTALL_TYPE_NPM
+      const extensionsToCheck = Object.entries(listData as Record<string, any>).filter(
+        ([, data]) => data.installed && data.installType === INSTALL_TYPE_NPM,
       );
 
-      await B.map(
+      await asyncmap(
         extensionsToCheck,
         async ([ext, data]) => {
           try {
@@ -969,7 +1009,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
             data.updateError = (e as Error).message;
           }
         },
-        {concurrency: MAX_CONCURRENT_REPO_FETCHES}
+        {concurrency: MAX_CONCURRENT_REPO_FETCHES},
       );
     });
   }
@@ -980,15 +1020,15 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
    */
   private async _addRepositoryUrlsToListData(listData: ExtensionList): Promise<void> {
     await spinWith(this.isJsonOutput, 'Fetching repository information', async () => {
-      await B.map(
-        _.values(listData),
+      await asyncmap(
+        Object.values(listData),
         async (data) => {
           const repoUrl = await this._getRepositoryUrl(data);
           if (repoUrl) {
             data.repositoryUrl = repoUrl;
           }
         },
-        {concurrency: MAX_CONCURRENT_REPO_FETCHES}
+        {concurrency: MAX_CONCURRENT_REPO_FETCHES},
       );
     });
   }
@@ -999,9 +1039,9 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
    */
   private async _displayNormalListOutput(
     listData: ExtensionList,
-    showUpdates: boolean
+    showUpdates: boolean,
   ): Promise<ExtensionList> {
-    for (const [name, data] of _.toPairs(listData)) {
+    for (const [name, data] of Object.entries(listData)) {
       const line = await this._formatExtensionLine(name, data, showUpdates);
       this.log.log(line);
     }
@@ -1016,15 +1056,15 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
   private async _formatExtensionLine(
     name: string,
     data: ExtensionListData,
-    showUpdates: boolean
+    showUpdates: boolean,
   ): Promise<string> {
     if (data.installed) {
       const installTxt = this._formatInstallText(data);
       const updateTxt = showUpdates ? this._formatUpdateText(data) : '';
-      return `- ${name.yellow}${installTxt}${updateTxt}`;
+      return `- ${console.styleText('yellow', name)}${installTxt}${updateTxt}`;
     }
-    const installTxt = ' [not installed]'.grey;
-    return `- ${name.yellow}${installTxt}`;
+    const installTxt = console.styleText('grey', ' [not installed]');
+    return `- ${console.styleText('yellow', name)}${installTxt}`;
   }
 
   /**
@@ -1033,14 +1073,17 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
    */
   private _formatInstallText(data: ExtensionListData): string {
     const {installType, installSpec, version} = data;
-    let typeTxt;
+    let typeTxt: string;
+    let isTypeTextStyled = false;
     switch (installType) {
       case INSTALL_TYPE_GIT:
       case INSTALL_TYPE_GITHUB:
-        typeTxt = `(cloned from ${installSpec})`.yellow;
+        typeTxt = console.styleText('yellow', `(cloned from ${installSpec})`);
+        isTypeTextStyled = true;
         break;
       case INSTALL_TYPE_LOCAL:
-        typeTxt = `(linked from ${installSpec})`.magenta;
+        typeTxt = console.styleText('magenta', `(linked from ${installSpec})`);
+        isTypeTextStyled = true;
         break;
       case INSTALL_TYPE_DEV:
         typeTxt = '(dev mode)';
@@ -1048,7 +1091,10 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
       default:
         typeTxt = '(npm)';
     }
-    return `@${String(version).yellow} ${('[installed ' + typeTxt + ']').green}`;
+    const installLabelStart = console.styleText('green', '[installed ');
+    const installLabelEnd = console.styleText('green', ']');
+    const installTypeText = isTypeTextStyled ? typeTxt : console.styleText('green', typeTxt);
+    return `${console.styleText('yellow', `@${String(version)}`)} ${installLabelStart}${installTypeText}${installLabelEnd}`;
   }
 
   /**
@@ -1058,17 +1104,17 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
   private _formatUpdateText(data: ExtensionListData): string {
     const {updateVersion, unsafeUpdateVersion, upToDate, updateError} = data;
     if (updateError) {
-      return ` [Cannot check for updates: ${updateError}]`.red;
+      return console.styleText('red', ` [Cannot check for updates: ${updateError}]`);
     }
     let txt = '';
     if (updateVersion) {
-      txt += ` [${updateVersion} available]`.magenta;
+      txt += console.styleText('magenta', ` [${updateVersion} available]`);
     }
     if (upToDate) {
-      txt += ` [Up to date]`.green;
+      txt += console.styleText('green', ' [Up to date]');
     }
     if (unsafeUpdateVersion) {
-      txt += ` [${unsafeUpdateVersion} available (potentially unsafe)]`.cyan;
+      txt += console.styleText('cyan', ` [${unsafeUpdateVersion} available (potentially unsafe)]`);
     }
     return txt;
   }
@@ -1079,9 +1125,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
    */
   private async _getRepositoryUrl(data: ExtensionListData): Promise<string | null> {
     if (data.installed && data.installPath) {
-      return await this._getRepositoryUrlFromInstalled(
-        data
-      );
+      return await this._getRepositoryUrlFromInstalled(data);
     }
     if (data.pkgName && !data.installed) {
       return await this._getRepositoryUrlFromNpm(data.pkgName);
@@ -1150,12 +1194,19 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
     }
 
     await spinWith(this.isJsonOutput, `Checking if '${pkgName}' is compatible`, async () => {
-      const [serverVersion, extVersionRequirement] = await getRemoteExtensionVersionReq(pkgName, pkgVer);
-      if (serverVersion && extVersionRequirement && !semver.satisfies(serverVersion, extVersionRequirement)) {
+      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.`
+            `does not meet the currently installed one (${serverVersion}). Please install ` +
+            `a compatible server version first.`,
         );
       }
     });
@@ -1171,7 +1222,7 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
    */
   protected abstract validateExtensionFields(
     extMetadata: ExtMetadata<ExtType>,
-    installSpec: string
+    installSpec: string,
   ): void;
 
   /**
@@ -1194,29 +1245,35 @@ abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType
 export async function injectAppiumSymlinks(
   driverConfig: ExtensionConfig<any>,
   pluginConfig: ExtensionConfig<any>,
-  logger: AppiumLogger
+  logger: AppiumLogger,
 ): Promise<void> {
   const isNpmInstalledExtension = (
-    details: InstalledExtensionLike
-  ): details is InstalledExtensionLike & {installType: typeof INSTALL_TYPE_NPM; installPath: string} =>
-    details.installType === INSTALL_TYPE_NPM && Boolean(details.installPath);
+    details: InstalledExtensionLike,
+  ): details is InstalledExtensionLike & {
+    installType: typeof INSTALL_TYPE_NPM;
+    installPath: string;
+  } => details.installType === INSTALL_TYPE_NPM && Boolean(details.installPath);
 
   const installedExtensions = [
     ...Object.values(driverConfig.installedExtensions || {}),
     ...Object.values(pluginConfig.installedExtensions || {}),
   ] as InstalledExtensionLike[];
 
-  const installPaths = _.compact(installedExtensions
-    .filter((details): details is InstalledExtensionLike => Boolean(details))
-    .filter(isNpmInstalledExtension)
-    .map((details) => details.installPath));
+  const installPaths = compact(
+    installedExtensions
+      .filter((details): details is InstalledExtensionLike => 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.
   // We also inject the symlink into other installed extensions' node_modules folders
   // as these might be cleaned up unexpectedly by npm
   // (see https://github.com/appium/python-client/pull/1177#issuecomment-3419826643).
   await Promise.all(
-    installPaths.map((installPath) => injectAppiumSymlink(path.join(installPath, 'node_modules'), logger))
+    installPaths.map((installPath) =>
+      injectAppiumSymlink(path.join(installPath, 'node_modules'), logger),
+    ),
   );
 }
 
@@ -1224,9 +1281,16 @@ export async function injectAppiumSymlinks(
  * Omits `driverName`/`pluginName` props from the receipt to make a {@linkcode ExtManifest}
  */
 function receiptToManifest<ExtType extends ExtensionType>(
-  receipt: ExtInstallReceipt<ExtType>
+  receipt: ExtInstallReceipt<ExtType>,
 ): ExtManifest<ExtType> {
-  return _.omit(receipt, 'driverName', 'pluginName') as ExtManifest<ExtType>;
+  if ('driverName' in receipt) {
+    const {driverName, ...manifest} = receipt as ExtInstallReceipt<'driver'>;
+    void driverName;
+    return manifest as unknown as ExtManifest<ExtType>;
+  }
+  const {pluginName, ...manifest} = receipt as ExtInstallReceipt<'plugin'>;
+  void pluginName;
+  return manifest as unknown as ExtManifest<ExtType>;
 }
 
 /**
@@ -1237,15 +1301,19 @@ function receiptToManifest<ExtType extends ExtensionType>(
  */
 async function getRemoteExtensionVersionReq(
   pkgName: string,
-  pkgVer?: string
+  pkgVer?: string,
 ): Promise<[string, string | null]> {
-  const allDeps = await npm.getPackageInfo(
-    `${pkgName}${pkgVer ? `@${pkgVer}` : ``}`,
-    ['peerDependencies', 'dependencies']
-  );
-  const requiredVersionPair = _.flatMap(_.values(allDeps).map(_.toPairs))
+  const allDeps = await npm.getPackageInfo(`${pkgName}${pkgVer ? `@${pkgVer}` : ``}`, [
+    'peerDependencies',
+    'dependencies',
+  ]);
+  const requiredVersionPair = Object.values(allDeps)
+    .flatMap((dep) => Object.entries(dep ?? {}))
     .find(([name]) => name === 'appium');
-  return [npmPackage.version, requiredVersionPair ? requiredVersionPair[1] : null];
+  return [
+    npmPackage.version,
+    requiredVersionPair ? (requiredVersionPair[1] as string | null) : null,
+  ];
 }
 
 /**
@@ -1255,22 +1323,19 @@ async function getRemoteExtensionVersionReq(
  * @param dstFolder The destination folder where the symlink should be created
  */
 async function injectAppiumSymlink(dstFolder: string, logger: AppiumLogger): Promise<void> {
-  let appiumModuleRoot = '';
   try {
-    appiumModuleRoot = getAppiumModuleRoot();
-    const symlinkPath = path.join(dstFolder, path.basename(appiumModuleRoot));
-    if (await fs.exists(dstFolder) && !(await fs.exists(symlinkPath))) {
-      await fs.symlink(appiumModuleRoot, symlinkPath, system.isWindows() ? 'junction' : 'dir');
+    const symlinkPath = path.join(dstFolder, path.basename(appiumPackageRoot));
+    if ((await fs.exists(dstFolder)) && !(await fs.exists(symlinkPath))) {
+      await fs.symlink(appiumPackageRoot, symlinkPath, system.isWindows() ? 'junction' : 'dir');
     }
   } catch (error) {
     // This error is not fatal, we may still doing just fine if the module being loaded is a CJS one
     logger.info(
-      `Cannot create a symlink to the appium module '${appiumModuleRoot}' in '${dstFolder}'. ` +
-      `Original error: ${error.message}`
+      `Cannot create a symlink to the appium module '${appiumPackageRoot}' in '${dstFolder}'. ` +
+        `Original error: ${error instanceof Error ? error.message : String(error)}`,
     );
   }
 }
 
 export default ExtensionCliCommand;
 export {ExtensionCliCommand as ExtensionCommand};
-