appium 3.5.0 → 3.5.1

package/lib/cli/extension.ts

@@ -8,12 +8,10 @@ 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
-);
+export const commandClasses = Object.freeze({
+  [DRIVER_TYPE]: DriverCliCommand,
+  [PLUGIN_TYPE]: PluginCliCommand,
+} as const);
 
 export type ExtCommand<ExtType extends ExtensionType> = ExtType extends DriverType
   ? Class<DriverCliCommand>

package/lib/cli/parser.ts

@@ -1,8 +1,7 @@
-import {fs} from '@appium/support';
 import {ArgumentParser} from 'argparse';
 import type {SubArgumentParserOptions, SubParser} from 'argparse';
-import _ from 'lodash';
 import path from 'node:path';
+import {setPath} from '../utils';
 import type {DriverType, PluginType} from '@appium/types';
 import type {CliExtensionSubcommand} from 'appium/types';
 import {
@@ -15,10 +14,10 @@ import {
   EXT_SUBCOMMAND_UPDATE,
   PLUGIN_TYPE,
   SERVER_SUBCOMMAND,
-  SETUP_SUBCOMMAND
+  SETUP_SUBCOMMAND,
 } from '../constants';
 import {finalizeSchema, getAllArgSpecs, getArgSpec, hasArgSpec} from '../schema';
-import {rootDir} from '../helpers/build';
+import {APPIUM_VER} from '../helpers/build';
 import {getExtensionArgs, getServerArgs} from './args';
 import type {ArgumentDefinitions} from './args';
 import {
@@ -28,7 +27,7 @@ import {
   SUBCOMMAND_BROWSER,
   SUBCOMMAND_RESET,
   getPresetDrivers,
-  determinePlatformName
+  determinePlatformName,
 } from './setup-command';
 
 export const EXTRA_ARGS = 'extraArgs';
@@ -38,10 +37,18 @@ export const EXTRA_ARGS = 'extraArgs';
  * will automatically inject the `server` subcommand.
  */
 const NON_SERVER_ARGS = Object.freeze(
-  new Set([SETUP_SUBCOMMAND, DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND, '-h', '--help', '-v', '--version'])
+  new Set([
+    SETUP_SUBCOMMAND,
+    DRIVER_TYPE,
+    PLUGIN_TYPE,
+    SERVER_SUBCOMMAND,
+    '-h',
+    '--help',
+    '-v',
+    '--version',
+  ]),
 );
 
-const version = fs.readPackageJsonFrom(rootDir).version;
 type LooseArgsMap = {[key: string]: any};
 type TransformedArgsMap = LooseArgsMap & {[EXTRA_ARGS]: string[]};
 
@@ -82,7 +89,7 @@ export class ArgParser {
 
     parser.add_argument('-v', '--version', {
       action: 'version',
-      version,
+      version: APPIUM_VER,
     });
 
     const subParsers = parser.add_subparsers({dest: 'subcommand'});
@@ -129,23 +136,19 @@ export class ArgParser {
    */
   private static _transformParsedArgs(
     args: LooseArgsMap,
-    unknownArgs: string[] = []
+    unknownArgs: string[] = [],
   ): TransformedArgsMap {
-    const result = _.reduce(
-      args,
-      (unpacked, value, 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
-          unpacked[key] = value;
-        }
-        return unpacked;
-      },
-      {}
-    );
+    const result = Object.entries(args).reduce((unpacked: LooseArgsMap, [key, value]) => {
+      const spec = hasArgSpec(key) ? getArgSpec(key) : undefined;
+      if (value !== undefined && spec) {
+        const {dest} = spec;
+        setPath(unpacked as Record<string, unknown>, dest, value);
+      } else {
+        // this could be anything that isn't a server arg
+        unpacked[key] = value;
+      }
+      return unpacked;
+    }, {} as LooseArgsMap);
     result[EXTRA_ARGS] = unknownArgs;
     return result as TransformedArgsMap;
   }
@@ -270,7 +273,6 @@ export class ArgParser {
         `drivers and plugins, and remove their related manifest files.`,
     });
 
-
     ArgParser._patchExit(setupParser);
     const extSubParsers = setupParser.add_subparsers({
       dest: `setupCommand`,
@@ -281,23 +283,23 @@ export class ArgParser {
         command: SUBCOMMAND_MOBILE,
         help:
           `The preset for mobile devices ` +
-          `(drivers: ${_.join(getPresetDrivers(SUBCOMMAND_MOBILE), ',')}; plugins: ${DEFAULT_PLUGINS})`
+          `(drivers: ${getPresetDrivers(SUBCOMMAND_MOBILE).join(',')}; plugins: ${DEFAULT_PLUGINS})`,
       },
       {
         command: SUBCOMMAND_BROWSER,
         help:
           `The preset for desktop browsers ` +
-          `(drivers: ${_.join(getPresetDrivers(SUBCOMMAND_BROWSER), ',')}; plugins: ${DEFAULT_PLUGINS})`
+          `(drivers: ${getPresetDrivers(SUBCOMMAND_BROWSER).join(',')}; plugins: ${DEFAULT_PLUGINS})`,
       },
       {
         command: SUBCOMMAND_DESKTOP,
         help:
           `The preset for desktop applications ` +
-          `(drivers: ${_.join(getPresetDrivers(SUBCOMMAND_DESKTOP), ',')}; plugins: ${DEFAULT_PLUGINS})`
+          `(drivers: ${getPresetDrivers(SUBCOMMAND_DESKTOP).join(',')}; plugins: ${DEFAULT_PLUGINS})`,
       },
       {
         command: SUBCOMMAND_RESET,
-        help: 'Remove all installed drivers and plugins'
+        help: 'Remove all installed drivers and plugins',
       },
     ];
 
@@ -348,7 +350,7 @@ export class ArgParser {
         // eslint-disable-next-line no-console
         console.error(); // need an extra space since argparse prints usage.
         // eslint-disable-next-line no-console
-        console.error(err.message);
+        console.error(err instanceof Error ? err.message : String(err));
         process.exit(1);
       }
     }

package/lib/cli/plugin-command.ts

@@ -1,4 +1,4 @@
-import _ from 'lodash';
+import {console, util} from '@appium/support';
 import type {ExtMetadata, ExtRecord, InstallType} from 'appium/types';
 import ExtensionCliCommand from './extension-command';
 import type {
@@ -28,7 +28,11 @@ export default class PluginCliCommand extends ExtensionCliCommand<'plugin'> {
    *
    * @param opts - install options
    */
-  async install({plugin, installType, packageName}: PluginInstallOpts): Promise<ExtRecord<'plugin'>> {
+  async install({
+    plugin,
+    installType,
+    packageName,
+  }: PluginInstallOpts): Promise<ExtRecord<'plugin'>> {
     return await super._install({
       installSpec: plugin,
       installType,
@@ -89,7 +93,10 @@ export default class PluginCliCommand extends ExtensionCliCommand<'plugin'> {
    * @returns formatted success text
    */
   override getPostInstallText({extName, extData}: ExtensionArgs<'plugin'>): PostInstallText {
-    return `Plugin ${extName}@${extData.version} successfully installed`.green;
+    return console.styleText(
+      'green',
+      `Plugin ${extName}@${extData.version} successfully installed`,
+    );
   }
 
   /**
@@ -101,16 +108,20 @@ export default class PluginCliCommand extends ExtensionCliCommand<'plugin'> {
    * @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]),
-      []
+  override validateExtensionFields(
+    pluginMetadata: ExtMetadata<'plugin'>,
+    installSpec: string,
+  ): void {
+    const missingFields = REQ_PLUGIN_FIELDS.reduce<string[]>(
+      (acc, field) =>
+        pluginMetadata[field as keyof typeof pluginMetadata] ? acc : [...acc, field],
+      [],
     );
 
-    if (!_.isEmpty(missingFields)) {
+    if (!util.isEmpty(missingFields)) {
       throw new Error(
         `Installed plugin "${installSpec}" did not expose correct fields for compatibility ` +
-          `with Appium. Missing fields: ${JSON.stringify(missingFields)}`
+          `with Appium. Missing fields: ${JSON.stringify(missingFields)}`,
       );
     }
   }

package/lib/cli/setup-command.ts

@@ -1,4 +1,3 @@
-import _ from 'lodash';
 import type {
   Args,
   CliCommandSetup,
@@ -6,13 +5,9 @@ import type {
   CliExtensionCommand,
   CliExtensionSubcommand,
 } from 'appium/types';
-import {
-  DESKTOP_BROWSERS,
-  DESKTOP_DRIVERS,
-  MOBILE_DRIVERS
-} from '../constants';
+import {DESKTOP_BROWSERS, DESKTOP_DRIVERS, MOBILE_DRIVERS} from '../constants';
 import {runExtensionCommand} from './extension';
-import { system, fs } from '@appium/support';
+import {system, fs} from '@appium/support';
 import {log} from '../logger';
 import type {ExtensionConfig} from '../extension/extension-config';
 
@@ -29,9 +24,9 @@ export const SUBCOMMAND_RESET = 'reset';
  * Driver names listed in KNOWN_DRIVERS to install by default
  */
 const PRESET_PAIRS = Object.freeze({
-  mobile: _.keys(MOBILE_DRIVERS),
-  desktop: _.keys(DESKTOP_DRIVERS),
-  browser: _.keys(DESKTOP_BROWSERS),
+  mobile: Object.keys(MOBILE_DRIVERS),
+  desktop: Object.keys(DESKTOP_DRIVERS),
+  browser: Object.keys(DESKTOP_BROWSERS),
 } as const);
 const DRIVERS_ONLY_MACOS = ['xcuitest', 'safari', 'mac2'];
 
@@ -49,19 +44,20 @@ type CliExtArgs = Args<CliExtensionCommand, CliExtensionSubcommand>;
 /**
  * Return a list of drivers available for current host platform.
  */
-export function getPresetDrivers(presetName: CliCommandSetupSubcommand): string[] {
-  return _.filter(PRESET_PAIRS[presetName], (driver) => {
-    if (_.includes(DRIVERS_ONLY_MACOS, driver)) {
+export function getPresetDrivers(
+  presetName: Exclude<CliCommandSetupSubcommand, 'reset'>,
+): string[] {
+  return PRESET_PAIRS[presetName].filter((driver) => {
+    if (DRIVERS_ONLY_MACOS.includes(driver)) {
       return system.isMac();
     }
 
-    if (_.includes(DRIVERS_ONLY_WINDOWS, driver)) {
+    if (DRIVERS_ONLY_WINDOWS.includes(driver)) {
       return system.isWindows();
     }
 
     return true;
   });
-
 }
 
 /**
@@ -85,7 +81,7 @@ export function determinePlatformName(): string {
 export async function runSetupCommand(
   preConfigArgs: Args<CliCommandSetup>,
   driverConfig: DriverConfig,
-  pluginConfig: PluginConfig
+  pluginConfig: PluginConfig,
 ): Promise<void> {
   switch (preConfigArgs.setupCommand) {
     case SUBCOMMAND_DESKTOP:
@@ -104,40 +100,45 @@ export async function runSetupCommand(
       await setupDefaultPlugins(pluginConfig);
       break;
   }
-};
+}
 
 /**
  * Resets all installed drivers and extensions
  */
-async function resetAllExtensions(driverConfig: DriverConfig, pluginConfig: PluginConfig): Promise<void> {
+async function resetAllExtensions(
+  driverConfig: DriverConfig,
+  pluginConfig: PluginConfig,
+): Promise<void> {
   const commandConfigs: [CliExtensionCommand, DriverConfig | PluginConfig][] = [
     ['driver', driverConfig],
     ['plugin', pluginConfig],
   ];
   for (const [command, config] of commandConfigs) {
-    for (const extensionName of _.keys(config.installedExtensions)) {
+    for (const extensionName of Object.keys(config.installedExtensions)) {
       try {
         await uninstallExtension(
           extensionName,
           extensionCommandArgs(command, extensionName, 'uninstall'),
-          config
+          config,
         );
       } catch (e) {
         log.warn(
           `${extensionName} ${command} cannot be uninstalled. Will delete the manifest anyway. ` +
-          `Original error: ${e.stack}`
+            `Original error: ${e instanceof Error ? e.stack : String(e)}`,
         );
       }
     }
 
     const manifestPath = config.manifestPath;
-    if (!manifestPath || !await fs.exists(manifestPath)) {
+    if (!manifestPath || !(await fs.exists(manifestPath))) {
       continue;
     }
 
     await fs.rimraf(manifestPath);
     if (await fs.exists(manifestPath)) {
-      throw new Error(`${command} manifest at '${manifestPath}' cannot be deleted. Is it accessible?`);
+      throw new Error(
+        `${command} manifest at '${manifestPath}' cannot be deleted. Is it accessible?`,
+      );
     } else {
       log.info(`Successfully deleted ${command} manifest at '${manifestPath}'`);
     }
@@ -168,9 +169,16 @@ async function setupDesktopAppDrivers(driverConfig: DriverConfig): Promise<void>
 /**
  * Install the given driver name. It skips the installation if the given driver name was already installed.
  */
-async function installDrivers(subcommand: CliCommandSetupSubcommand, driverConfig: DriverConfig): Promise<void> {
+async function installDrivers(
+  subcommand: Exclude<CliCommandSetupSubcommand, 'reset'>,
+  driverConfig: DriverConfig,
+): Promise<void> {
   for (const driverName of getPresetDrivers(subcommand)) {
-    await installExtension(driverName, extensionCommandArgs('driver', driverName, 'install'), driverConfig);
+    await installExtension(
+      driverName,
+      extensionCommandArgs('driver', driverName, 'install'),
+      driverConfig,
+    );
   }
 }
 
@@ -179,7 +187,11 @@ async function installDrivers(subcommand: CliCommandSetupSubcommand, driverConfi
  */
 async function setupDefaultPlugins(pluginConfig: PluginConfig): Promise<void> {
   for (const pluginName of DEFAULT_PLUGINS) {
-    await installExtension(pluginName, extensionCommandArgs('plugin', pluginName, 'install'), pluginConfig);
+    await installExtension(
+      pluginName,
+      extensionCommandArgs('plugin', pluginName, 'install'),
+      pluginConfig,
+    );
   }
 }
 
@@ -189,11 +201,13 @@ async function setupDefaultPlugins(pluginConfig: PluginConfig): Promise<void> {
 async function installExtension(
   extensionName: string,
   extensionConfigArgs: CliExtArgs,
-  extensionConfig: DriverConfig | PluginConfig
+  extensionConfig: DriverConfig | PluginConfig,
 ): Promise<void> {
-  if (_.keys(extensionConfig.installedExtensions).includes(extensionName)) {
-    log.info(`${extensionName} (${extensionConfig.installedExtensions[extensionName].version}) is already installed. ` +
-      `Skipping the installation.`);
+  if (Object.keys(extensionConfig.installedExtensions).includes(extensionName)) {
+    log.info(
+      `${extensionName} (${extensionConfig.installedExtensions[extensionName].version}) is already installed. ` +
+        `Skipping the installation.`,
+    );
     return;
   }
   await runExtensionCommand(extensionConfigArgs, extensionConfig);
@@ -205,11 +219,13 @@ async function installExtension(
 async function uninstallExtension(
   extensionName: string,
   extensionConfigArgs: CliExtArgs,
-  extensionConfig: DriverConfig | PluginConfig
+  extensionConfig: DriverConfig | PluginConfig,
 ): Promise<void> {
-  if (!_.keys(extensionConfig.installedExtensions).includes(extensionName)) {
-    log.info(`${extensionName} (${extensionConfig.installedExtensions[extensionName].version}) is not installed. ` +
-      `Skipping its uninstall.`);
+  if (!Object.keys(extensionConfig.installedExtensions).includes(extensionName)) {
+    log.info(
+      `${extensionName} (${extensionConfig.installedExtensions[extensionName].version}) is not installed. ` +
+        `Skipping its uninstall.`,
+    );
     return;
   }
   await runExtensionCommand(extensionConfigArgs, extensionConfig);
@@ -221,10 +237,9 @@ async function uninstallExtension(
 function extensionCommandArgs(
   extensionCommand: CliExtensionCommand,
   extensionName: string,
-  command: CliExtensionSubcommand
+  command: CliExtensionSubcommand,
 ): CliExtArgs {
-  return (extensionCommand === 'plugin')
-    ? {'subcommand': 'plugin', 'pluginCommand': command, 'plugin': extensionName}
-    : {'subcommand': 'driver', 'driverCommand': command, 'driver': extensionName};
+  return extensionCommand === 'plugin'
+    ? {subcommand: 'plugin', pluginCommand: command, plugin: extensionName}
+    : {subcommand: 'driver', driverCommand: command, driver: extensionName};
 }
-

package/lib/cli/utils.ts

@@ -1,5 +1,6 @@
 /* eslint-disable no-console */
 
+import {console as supportConsole} from '@appium/support';
 import ora from 'ora';
 
 export const JSON_SPACES = 4;
@@ -49,9 +50,9 @@ export function errAndQuit(json: boolean, msg: unknown): never {
   if (json) {
     console.log(JSON.stringify({error: String(msg)}, null, JSON_SPACES));
   } else {
-    console.error((String(msg) as any).red);
+    console.error(supportConsole.styleText('red', String(msg)));
     if ((msg as ErrorLike)?.stderr) {
-      console.error((String((msg as ErrorLike).stderr) as any).red);
+      console.error(supportConsole.styleText('red', String((msg as ErrorLike).stderr)));
     }
   }
   process.exit(1);
@@ -80,7 +81,7 @@ export function log(json: boolean, msg: string): void {
 export async function spinWith<T>(
   json: boolean,
   msg: string,
-  fn: () => T | Promise<T>
+  fn: () => T | Promise<T>,
 ): Promise<T> {
   if (json) {
     return await fn();

package/lib/doctor/doctor.ts

@@ -1,6 +1,4 @@
-import '@colors/colors';
-import _ from 'lodash';
-import {util, doctor, logger} from '@appium/support';
+import {console, doctor, logger, util} from '@appium/support';
 import type {AppiumLogger, DoctorCheckResult, IDoctorCheck} from '@appium/types';
 
 /**
@@ -35,7 +33,7 @@ export class Doctor {
     this.log = logger.getLogger('Doctor');
     this.checks = checks;
     this.checks
-      .filter((c) => _.isNil(c.log))
+      .filter((c) => !util.hasValue(c.log))
       .forEach((c) => {
         c.log = this.log;
       });
@@ -88,11 +86,11 @@ export class Doctor {
   }
 
   private async reportManualIssues(): Promise<boolean> {
-    const manualIssues = _.filter(this.issuesRequiredToFix, (f) => !f.check.hasAutofix());
-    const manualIssuesOptional = _.filter(this.issuesOptionalToFix, (f) => !f.check.hasAutofix());
+    const manualIssues = this.issuesRequiredToFix.filter((f) => !f.check.hasAutofix());
+    const manualIssuesOptional = this.issuesOptionalToFix.filter((f) => !f.check.hasAutofix());
 
     const handleIssues = async (headerLogs: string[], issues: DoctorIssue[]): Promise<void> => {
-      if (_.isEmpty(issues)) {
+      if (util.isEmpty(issues)) {
         return;
       }
 
@@ -111,7 +109,7 @@ export class Doctor {
           fixMessages.push(message);
         }
       }
-      for (const m of _.uniq(fixMessages)) {
+      for (const m of util.uniq(fixMessages)) {
         this.log.warn(` \u279C ${m}`);
       }
       this.log.info('');
@@ -122,14 +120,14 @@ export class Doctor {
         '### Manual Fixes Needed ###',
         'The configuration cannot be automatically fixed, please do the following first:',
       ],
-      manualIssues
+      manualIssues,
     );
     await handleIssues(
       [
         '### Optional Manual Fixes ###',
         'To fix these optional issues, please do the following manually:',
       ],
-      manualIssuesOptional
+      manualIssuesOptional,
     );
 
     if (manualIssues.length > 0) {
@@ -160,21 +158,21 @@ export class Doctor {
     const res = await f.check.diagnose();
     if (res.ok) {
       f.fixed = true;
-      this.log.info(` ${'\u2714'.green} ${res.message}`);
+      this.log.info(` ${console.styleText('green', '\u2714')} ${res.message}`);
       this.log.info(`### Fix was successfully applied ###`);
     } else {
-      this.log.info(` ${'\u2716'.red} ${res.message}`);
+      this.log.info(` ${console.styleText('red', '\u2716')} ${res.message}`);
       this.log.info(`### Fix was applied but issue remains ###`);
     }
   }
 
   private async runAutoFixes(): Promise<boolean> {
-    const autoFixes = _.filter(this.foundIssues, (f) => f.check.hasAutofix());
+    const autoFixes = this.foundIssues.filter((f) => f.check.hasAutofix());
     for (const f of autoFixes) {
       await this.runAutoFix(f);
       this.log.info('');
     }
-    if (_.find(autoFixes, (f) => !f.fixed)) {
+    if (autoFixes.find((f) => !f.fixed)) {
       // a few issues remain.
       this.log.info('Bye! A few issues remain, fix manually and/or rerun doctor!');
       this.log.info('');
@@ -188,13 +186,13 @@ export class Doctor {
 
   private toIssue(result: DoctorCheckResult, check: IDoctorCheck): DoctorIssue | null {
     if (result.ok) {
-      this.log.info(` ${'\u2714'.green} ${result.message}`);
+      this.log.info(` ${console.styleText('green', '\u2714')} ${result.message}`);
       return null;
     }
 
     const errorMessage = result.optional
-      ? ` ${'\u2716'.yellow} ${result.message}`
-      : ` ${'\u2716'.red} ${result.message}`;
+      ? ` ${console.styleText('yellow', '\u2716')} ${result.message}`
+      : ` ${console.styleText('red', '\u2716')} ${result.message}`;
     this.log.warn(errorMessage);
     return {
       error: errorMessage,

package/lib/extension/driver-config.ts

@@ -1,4 +1,4 @@
-import _ from 'lodash';
+import {util} from '@appium/support';
 import type {DriverClass, DriverType, StringRecord} from '@appium/types';
 import type {ExtManifest, ExtName, ExtRecord} from 'appium/types';
 import {DRIVER_TYPE} from '../constants';
@@ -25,7 +25,7 @@ export class DriverConfig extends ExtensionConfig<DriverType> {
     const instance = new DriverConfig(manifest);
     if (DriverConfig.getInstance(manifest)) {
       throw new Error(
-        `Manifest with APPIUM_HOME ${manifest.appiumHome} already has a DriverConfig; use DriverConfig.getInstance() to retrieve it.`
+        `Manifest with APPIUM_HOME ${manifest.appiumHome} already has a DriverConfig; use DriverConfig.getInstance() to retrieve it.`,
       );
     }
     DriverConfig._instances.set(manifest, instance);
@@ -43,7 +43,7 @@ export class DriverConfig extends ExtensionConfig<DriverType> {
 
   public override extensionDesc(
     driverName: ExtName<DriverType>,
-    {version, automationName}: ExtManifest<DriverType>
+    {version, automationName}: ExtManifest<DriverType>,
   ): string {
     return `${String(driverName)}@${version} (automationName '${automationName}')`;
   }
@@ -52,27 +52,30 @@ export class DriverConfig extends ExtensionConfig<DriverType> {
     automationName,
     platformName,
   }: C): Promise<MatchedDriver> {
-    if (!_.isString(platformName)) {
+    if (typeof platformName !== 'string') {
       throw new Error('You must include a platformName capability');
     }
 
-    if (!_.isString(automationName)) {
+    if (typeof automationName !== 'string') {
       throw new Error('You must include an automationName capability');
     }
 
     log.info(
       `Attempting to find matching driver for automationName ` +
-        `'${automationName}' and platformName '${platformName}'`
+        `'${automationName}' and platformName '${platformName}'`,
     );
 
     try {
-      const {driverName, mainClass, version} = this._getDriverBySupport(automationName, platformName);
+      const {driverName, mainClass, version} = this._getDriverBySupport(
+        automationName,
+        platformName,
+      );
       log.info(`The '${driverName}' driver was installed and matched caps.`);
       log.info(`Will require it at ${this.getInstallPath(driverName)}`);
       const driver = await this.requireAsync(driverName as ExtName<DriverType>);
       if (!driver) {
         throw new Error(
-          `Driver '${driverName}' did not export a class with name '${mainClass}'. Contact the author of the driver!`
+          `Driver '${driverName}' did not export a class with name '${mainClass}'. Contact the author of the driver!`,
         );
       }
       return {driver, version, driverName};
@@ -89,25 +92,25 @@ export class DriverConfig extends ExtensionConfig<DriverType> {
 
   protected override getConfigProblems(
     extManifest: ExtManifest<DriverType>,
-    extName: string
+    extName: string,
   ): ExtManifestProblem[] {
     void extName;
     const problems: ExtManifestProblem[] = [];
     const {platformNames, automationName} = extManifest;
 
-    if (!_.isArray(platformNames)) {
+    if (!Array.isArray(platformNames)) {
       problems.push({
         err: 'Missing or incorrect supported platformNames list.',
         val: platformNames,
       });
-    } else if (_.isEmpty(platformNames)) {
+    } else if (util.isEmpty(platformNames)) {
       problems.push({
         err: 'Empty platformNames list.',
         val: platformNames,
       });
     } else {
       for (const pName of platformNames) {
-        if (!_.isString(pName)) {
+        if (typeof pName !== 'string') {
           problems.push({
             err: 'Incorrectly formatted platformName.',
             val: pName,
@@ -116,7 +119,7 @@ export class DriverConfig extends ExtensionConfig<DriverType> {
       }
     }
 
-    if (!_.isString(automationName)) {
+    if (typeof automationName !== 'string') {
       problems.push({
         err: 'Missing or incorrect automationName',
         val: automationName,
@@ -137,13 +140,15 @@ export class DriverConfig extends ExtensionConfig<DriverType> {
 
   private _getDriverBySupport(
     matchAutomationName: string,
-    matchPlatformName: string
+    matchPlatformName: string,
   ): ExtManifest<DriverType> & {driverName: string} {
     const drivers = this.installedExtensions;
-    for (const [driverName, driverData] of _.toPairs(drivers)) {
+    for (const [driverName, driverData] of Object.entries(drivers)) {
       const {automationName, platformNames} = driverData;
       const aNameMatches = automationName.toLowerCase() === matchAutomationName.toLowerCase();
-      const pNameMatches = _.includes(platformNames.map((p) => _.toLower(p)), matchPlatformName.toLowerCase());
+      const pNameMatches = platformNames
+        .map((p) => p.toLowerCase())
+        .includes(matchPlatformName.toLowerCase());
 
       if (aNameMatches && pNameMatches) {
         return {driverName, ...driverData};
@@ -155,7 +160,7 @@ export class DriverConfig extends ExtensionConfig<DriverType> {
             `'${automationName}', but Appium could not find ` +
             `support for platformName '${matchPlatformName}'. Supported ` +
             `platformNames are: ` +
-            JSON.stringify(platformNames)
+            JSON.stringify(platformNames),
         );
       }
     }