appium 3.5.2 → 3.6.0

package/lib/cli/plugin-command.ts

@@ -1,6 +1,8 @@
 import {console, util} from '@appium/support';
 import type {ExtMetadata, ExtRecord, InstallType} from 'appium/types';
-import ExtensionCliCommand from './extension-command';
+
+import {KNOWN_PLUGINS} from '../constants';
+import {ExtensionCliCommand} from './extension-command';
 import type {
   ExtensionArgs,
   ExtensionCommandOptions,
@@ -8,7 +10,6 @@ import type {
   PostInstallText,
   RunOutput,
 } from './extension-command';
-import {KNOWN_PLUGINS} from '../constants';
 
 const REQ_PLUGIN_FIELDS = ['pluginName', 'mainClass'];
 type PluginInstallOpts = {plugin: string; installType: InstallType; packageName?: string};
@@ -28,11 +29,7 @@ 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,
@@ -93,10 +90,7 @@ export default class PluginCliCommand extends ExtensionCliCommand<'plugin'> {
    * @returns formatted success text
    */
   override getPostInstallText({extName, extData}: ExtensionArgs<'plugin'>): PostInstallText {
-    return console.styleText(
-      'green',
-      `Plugin ${extName}@${extData.version} successfully installed`,
-    );
+    return console.styleText('green', `Plugin ${extName}@${extData.version} successfully installed`);
   }
 
   /**
@@ -108,13 +102,9 @@ 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 {
+  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],
+      (acc, field) => (pluginMetadata[field as keyof typeof pluginMetadata] ? acc : [...acc, field]),
       [],
     );
 

package/lib/cli/setup-command.ts

@@ -1,3 +1,4 @@
+import {fs, system} from '@appium/support';
 import type {
   Args,
   CliCommandSetup,
@@ -5,11 +6,11 @@ import type {
   CliExtensionCommand,
   CliExtensionSubcommand,
 } from 'appium/types';
+
 import {DESKTOP_BROWSERS, DESKTOP_DRIVERS, MOBILE_DRIVERS} from '../constants';
-import {runExtensionCommand} from './extension';
-import {system, fs} from '@appium/support';
-import {log} from '../logger';
 import type {ExtensionConfig} from '../extension/extension-config';
+import {log} from '../logger';
+import {runExtensionCommand} from './extension';
 
 /**
  * Subcommands of preset for setup
@@ -44,9 +45,7 @@ type CliExtArgs = Args<CliExtensionCommand, CliExtensionSubcommand>;
 /**
  * Return a list of drivers available for current host platform.
  */
-export function getPresetDrivers(
-  presetName: Exclude<CliCommandSetupSubcommand, 'reset'>,
-): string[] {
+export function getPresetDrivers(presetName: Exclude<CliCommandSetupSubcommand, 'reset'>): string[] {
   return PRESET_PAIRS[presetName].filter((driver) => {
     if (DRIVERS_ONLY_MACOS.includes(driver)) {
       return system.isMac();
@@ -105,10 +104,7 @@ export async function runSetupCommand(
 /**
  * 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],
@@ -116,11 +112,7 @@ async function resetAllExtensions(
   for (const [command, config] of commandConfigs) {
     for (const extensionName of Object.keys(config.installedExtensions)) {
       try {
-        await uninstallExtension(
-          extensionName,
-          extensionCommandArgs(command, extensionName, 'uninstall'),
-          config,
-        );
+        await uninstallExtension(extensionName, extensionCommandArgs(command, extensionName, 'uninstall'), config);
       } catch (e) {
         log.warn(
           `${extensionName} ${command} cannot be uninstalled. Will delete the manifest anyway. ` +
@@ -136,9 +128,7 @@ async function resetAllExtensions(
 
     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}'`);
     }
@@ -174,11 +164,7 @@ async function installDrivers(
   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);
   }
 }
 
@@ -187,11 +173,7 @@ async function installDrivers(
  */
 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);
   }
 }
 

package/lib/cli/utils.ts

@@ -78,11 +78,7 @@ export function log(json: boolean, msg: string): void {
  * @param fn - function to wrap with spinning
  * @returns result of `fn`
  */
-export async function spinWith<T>(
-  json: boolean,
-  msg: string,
-  fn: () => T | Promise<T>,
-): Promise<T> {
+export async function spinWith<T>(json: boolean, msg: string, fn: () => T | Promise<T>): Promise<T> {
   if (json) {
     return await fn();
   }

package/lib/doctor/doctor.ts

@@ -123,10 +123,7 @@ export class Doctor {
       manualIssues,
     );
     await handleIssues(
-      [
-        '### Optional Manual Fixes ###',
-        'To fix these optional issues, please do the following manually:',
-      ],
+      ['### Optional Manual Fixes ###', 'To fix these optional issues, please do the following manually:'],
       manualIssuesOptional,
     );
 

package/lib/extension/driver-config.ts

@@ -1,6 +1,7 @@
 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';
 import {log} from '../logger';
 import type {ExtManifestProblem} from './extension-config';
@@ -48,10 +49,7 @@ export class DriverConfig extends ExtensionConfig<DriverType> {
     return `${String(driverName)}@${version} (automationName '${automationName}')`;
   }
 
-  async findMatchingDriver<C extends StringRecord>({
-    automationName,
-    platformName,
-  }: C): Promise<MatchedDriver> {
+  async findMatchingDriver<C extends StringRecord>({automationName, platformName}: C): Promise<MatchedDriver> {
     if (typeof platformName !== 'string') {
       throw new Error('You must include a platformName capability');
     }
@@ -66,10 +64,7 @@ export class DriverConfig extends ExtensionConfig<DriverType> {
     );
 
     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>);
@@ -90,10 +85,7 @@ export class DriverConfig extends ExtensionConfig<DriverType> {
     }
   }
 
-  protected override getConfigProblems(
-    extManifest: ExtManifest<DriverType>,
-    extName: string,
-  ): ExtManifestProblem[] {
+  protected override getConfigProblems(extManifest: ExtManifest<DriverType>, extName: string): ExtManifestProblem[] {
     void extName;
     const problems: ExtManifestProblem[] = [];
     const {platformNames, automationName} = extManifest;
@@ -146,9 +138,7 @@ export class DriverConfig extends ExtensionConfig<DriverType> {
     for (const [driverName, driverData] of Object.entries(drivers)) {
       const {automationName, platformNames} = driverData;
       const aNameMatches = automationName.toLowerCase() === matchAutomationName.toLowerCase();
-      const pNameMatches = platformNames
-        .map((p) => p.toLowerCase())
-        .includes(matchPlatformName.toLowerCase());
+      const pNameMatches = platformNames.map((p) => p.toLowerCase()).includes(matchPlatformName.toLowerCase());
 
       if (aNameMatches && pNameMatches) {
         return {driverName, ...driverData};

package/lib/extension/extension-config.ts

@@ -1,25 +1,22 @@
-import type {ExtensionType} from '@appium/types';
-import type {ExtClass, ExtManifest, ExtName, ExtRecord, InstallType} from 'appium/types';
-import type {SchemaObject} from 'ajv';
-import {util, fs, system} from '@appium/support';
 import path from 'node:path';
-import {capitalize, resolveFrom} from '../utils';
 import {pathToFileURL} from 'node:url';
+
+import {fs, system, util} from '@appium/support';
+import type {ExtensionType, StringRecord} from '@appium/types';
+import type {SchemaObject} from 'ajv';
+import type {ExtClass, ExtManifest, ExtName, ExtRecord, InstallType} from 'appium/types';
 import {satisfies} from 'semver';
-import {commandClasses} from '../cli/extension';
+
 import type {
   ExtensionList,
   ExtensionListData,
   InstalledExtensionListData,
+  ExtensionCliCommand,
 } from '../cli/extension-command';
-import type {ExtCommand} from '../cli/extension';
 import {APPIUM_VER} from '../helpers/build';
 import {log} from '../logger';
-import {
-  ALLOWED_SCHEMA_EXTENSIONS,
-  isAllowedSchemaFileExtension,
-  registerSchema,
-} from '../schema/schema';
+import {ALLOWED_SCHEMA_EXTENSIONS, isAllowedSchemaFileExtension, registerSchema} from '../schema/schema';
+import {capitalize, resolveFrom} from '../utils';
 import type {Manifest} from './manifest';
 
 const DEFAULT_ENTRY_POINT = 'index.js';
@@ -138,10 +135,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
    * @param extName - Extension key as stored in the manifest
    * @param extManifest - Manifest entry for that extension
    */
-  async getProblems(
-    extName: string,
-    extManifest: ExtManifest<ExtType>,
-  ): Promise<ExtManifestProblem[]> {
+  async getProblems(extName: string, extManifest: ExtManifest<ExtType>): Promise<ExtManifestProblem[]> {
     return [
       ...this.getGenericConfigProblems(extManifest, extName),
       ...this.getConfigProblems(extManifest, extName),
@@ -182,15 +176,10 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
       }
       // remove this extension from the list since it's not valid
       errorSummaries.push(
-        `${this.extensionType} "${extName}" had ${util.pluralize(
-          'error',
-          problems.length,
-        )} and will not be available:`,
+        `${this.extensionType} "${extName}" had ${util.pluralize('error', problems.length)} and will not be available:`,
       );
       for (const problem of problems) {
-        errorSummaries.push(
-          `  - ${problem.err} (Actual value: ` + `${JSON.stringify(problem.val)})`,
-        );
+        errorSummaries.push(`  - ${problem.err} (Actual value: ` + `${JSON.stringify(problem.val)})`);
       }
     }
     const warningSummaries: string[] = [];
@@ -258,10 +247,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
    *
    * Pass `{ write: false }` to defer flushing until a later manifest write.
    */
-  async removeExtension(
-    extName: ExtName<ExtType>,
-    {write = true}: ExtensionConfigMutationOpts = {},
-  ): Promise<void> {
+  async removeExtension(extName: ExtName<ExtType>, {write = true}: ExtensionConfigMutationOpts = {}): Promise<void> {
     this.manifest.deleteExtension(this.extensionType, extName);
     if (write) {
       await this.manifest.write();
@@ -336,19 +322,11 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
     extName: string,
     extManifest: ExtManifestWithSchema<ExtType>,
   ): Promise<SchemaObject | undefined> {
-    return await ExtensionConfig._readExtensionSchema(
-      this.appiumHome,
-      this.extensionType,
-      extName,
-      extManifest,
-    );
+    return await ExtensionConfig._readExtensionSchema(this.appiumHome, this.extensionType, extName, extManifest);
   }
 
   /** Optional async warnings for this extension kind; override in subclasses when needed. */
-  protected async getConfigWarnings(
-    _extManifest: ExtManifest<ExtType>,
-    _extName: string,
-  ): Promise<string[]> {
+  protected async getConfigWarnings(_extManifest: ExtManifest<ExtType>, _extName: string): Promise<string[]> {
     void _extManifest;
     void _extName;
     return [];
@@ -374,16 +352,15 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
       warningMap.set(extName, warnings);
     }
 
-    const {errorSummaries, warningSummaries} = this.getValidationResultSummaries(
-      errorMap,
-      warningMap,
-    );
+    const {errorSummaries, warningSummaries} = this.getValidationResultSummaries(errorMap, warningMap);
 
     if (!util.isEmpty(errorSummaries)) {
       log.error(
-        `Appium encountered ${util.pluralize('error', errorMap.size, true)} while validating ${
-          this.extensionType
-        }s found in manifest ${this.manifestPath}`,
+        `Appium encountered ${util.pluralize(
+          'error',
+          errorMap.size,
+          true,
+        )} while validating ${this.extensionType}s found in manifest ${this.manifestPath}`,
       );
       for (const summary of errorSummaries) {
         log.error(summary);
@@ -411,8 +388,10 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
     if (this.#listDataCache) {
       return this.#listDataCache;
     }
-    const CommandClass = commandClasses[this.extensionType] as ExtCommand<ExtType>;
-    const cmd = new CommandClass({config: this, json: true});
+    // Import here to avoid circular dependency with cli/extension
+    const {commandClasses} = await import('../cli/extension.js');
+    const CommandClass = (commandClasses as StringRecord)[this.extensionType];
+    const cmd = new CommandClass({config: this, json: true}) as ExtensionCliCommand<ExtType>;
     const listData = await cmd.list({showInstalled: true, showUpdates: true});
     this.#listDataCache = listData;
     return listData;
@@ -421,10 +400,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
   /**
    * Warnings about manifest install fields and Appium peer dependency compatibility for one extension.
    */
-  protected async getGenericConfigWarnings(
-    extManifest: ExtManifest<ExtType>,
-    extName: string,
-  ): Promise<string[]> {
+  protected async getGenericConfigWarnings(extManifest: ExtManifest<ExtType>, extName: string): Promise<string[]> {
     const {appiumVersion, installSpec, installType, pkgName} = extManifest;
     const warnings: string[] = [];
 
@@ -440,11 +416,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
     const extTypeText = capitalize(this.extensionType);
 
     if (invalidFields.length) {
-      const invalidFieldsEnumerationText = util.pluralize(
-        'invalid or missing field',
-        invalidFields.length,
-        true,
-      );
+      const invalidFieldsEnumerationText = util.pluralize('invalid or missing field', invalidFields.length, true);
       const invalidFieldsText = invalidFields.map((field) => `"${field}"`).join(', ');
 
       warnings.push(
@@ -499,10 +471,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
   }
 
   /** Validates and registers extension CLI/config schema when the manifest defines a `schema` field. */
-  protected async getSchemaProblems(
-    extManifest: ExtManifest<ExtType>,
-    extName: string,
-  ): Promise<ExtManifestProblem[]> {
+  protected async getSchemaProblems(extManifest: ExtManifest<ExtType>, extName: string): Promise<ExtManifestProblem[]> {
     const problems: ExtManifestProblem[] = [];
     const {schema: argSchemaPath} = extManifest;
     if (ExtensionConfig.extDataHasSchema(extManifest)) {
@@ -518,9 +487,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
           }
         } else {
           problems.push({
-            err: `Schema file has unsupported extension. Allowed: ${[
-              ...ALLOWED_SCHEMA_EXTENSIONS,
-            ].join(', ')}`,
+            err: `Schema file has unsupported extension. Allowed: ${[...ALLOWED_SCHEMA_EXTENSIONS].join(', ')}`,
             val: argSchemaPath,
           });
         }
@@ -544,10 +511,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
   }
 
   /** Blocking issues for required manifest fields shared by all extensions (version, package name, main class). */
-  protected getGenericConfigProblems(
-    extManifest: ExtManifest<ExtType>,
-    extName: string,
-  ): ExtManifestProblem[] {
+  protected getGenericConfigProblems(extManifest: ExtManifest<ExtType>, extName: string): ExtManifestProblem[] {
     void extName;
     const {version, pkgName, mainClass} = extManifest;
     const problems: ExtManifestProblem[] = [];
@@ -577,10 +541,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
   }
 
   /** Driver- or plugin-specific blocking validation; override in subclasses when needed. */
-  protected getConfigProblems(
-    _extManifest: ExtManifest<ExtType>,
-    _extName: string,
-  ): ExtManifestProblem[] {
+  protected getConfigProblems(_extManifest: ExtManifest<ExtType>, _extName: string): ExtManifestProblem[] {
     void _extManifest;
     void _extName;
     return [];
@@ -604,13 +565,11 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
       if (extensionManifest.type === 'module' && extensionManifest.exports) {
         entryPointRelativePath = resolveEsmEntryPoint(extensionManifest.exports);
       }
-      entryPointRelativePath =
-        entryPointRelativePath ?? extensionManifest.main ?? DEFAULT_ENTRY_POINT;
+      entryPointRelativePath = entryPointRelativePath ?? extensionManifest.main ?? DEFAULT_ENTRY_POINT;
     } catch (e: any) {
-      throw new ReferenceError(
-        `Could not find the ${this.extensionType} installed at ${moduleRoot}: ${e.message}`,
-        {cause: e},
-      );
+      throw new ReferenceError(`Could not find the ${this.extensionType} installed at ${moduleRoot}: ${e.message}`, {
+        cause: e,
+      });
     }
     const entryPointFullPath = path.resolve(moduleRoot, entryPointRelativePath as string);
     if (!(await fs.exists(entryPointFullPath))) {
@@ -633,10 +592,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
    * @param extName - Manifest key
    * @param extManifest - Entry used for version and kind-specific labels
    */
-  public abstract extensionDesc(
-    extName: ExtName<ExtType>,
-    extManifest: ExtManifest<ExtType>,
-  ): string;
+  public abstract extensionDesc(extName: ExtName<ExtType>, extManifest: ExtManifest<ExtType>): string;
 }
 
 /**

package/lib/extension/index.ts

@@ -1,12 +1,13 @@
-import {util, timing} from '@appium/support';
-import {asyncmap} from 'asyncbox';
+import {timing, util} from '@appium/support';
 import type {DriverClass, ExtensionType, PluginClass} from '@appium/types';
 import type {ExtClass} from 'appium/types';
+import {asyncmap} from 'asyncbox';
+
 import {USE_ALL_PLUGINS} from '../constants';
 import {log} from '../logger';
+import {zip} from '../utils';
 import {DriverConfig} from './driver-config';
 import {Manifest} from './manifest';
-import {zip} from '../utils';
 import {PluginConfig} from './plugin-config';
 
 export type ExtensionConfigs = {
@@ -59,26 +60,18 @@ export async function getActivePlugins(
       if (pluginName in pluginConfig.installedExtensions) {
         filteredPluginNames.push(pluginName);
       } else if (pluginName === USE_ALL_PLUGINS) {
-        throw new Error(
-          `The reserved plugin name '${pluginName}' cannot be combined with other names.`,
-        );
+        throw new Error(`The reserved plugin name '${pluginName}' cannot be combined with other names.`);
       } else {
         const suffix = util.isEmpty(pluginConfig.installedExtensions)
           ? `You don't have any plugins installed yet.`
-          : `Only the following ${Object.keys(pluginConfig.installedExtensions).length === 1 ? `plugin is` : `plugins are`} ` +
-            `available: ${Object.keys(pluginConfig.installedExtensions)}`;
-        throw new Error(
-          `Could not load the plugin '${pluginName}' because it is not installed. ${suffix}`,
-        );
+          : `Only the following ${
+              Object.keys(pluginConfig.installedExtensions).length === 1 ? `plugin is` : `plugins are`
+            } ` + `available: ${Object.keys(pluginConfig.installedExtensions)}`;
+        throw new Error(`Could not load the plugin '${pluginName}' because it is not installed. ${suffix}`);
       }
     }
   }
-  const pairs = await importExtensions(
-    'plugin',
-    pluginConfig,
-    filteredPluginNames,
-    maxParallelImports,
-  );
+  const pairs = await importExtensions('plugin', pluginConfig, filteredPluginNames, maxParallelImports);
   return new Map(pairs as Array<[PluginClass, string]>);
 }
 
@@ -102,20 +95,14 @@ export async function getActiveDrivers(
       } else {
         const suffix = util.isEmpty(driverConfig.installedExtensions)
           ? `You don't have any drivers installed yet.`
-          : `Only the following ${Object.keys(driverConfig.installedExtensions).length === 1 ? `driver is` : `drivers are`} ` +
-            `available: ${Object.keys(driverConfig.installedExtensions)}`;
-        throw new Error(
-          `Could not load the driver '${driverName}' because it is not installed. ${suffix}`,
-        );
+          : `Only the following ${
+              Object.keys(driverConfig.installedExtensions).length === 1 ? `driver is` : `drivers are`
+            } ` + `available: ${Object.keys(driverConfig.installedExtensions)}`;
+        throw new Error(`Could not load the driver '${driverName}' because it is not installed. ${suffix}`);
       }
     }
   }
-  const pairs = await importExtensions(
-    'driver',
-    driverConfig,
-    filteredDriverNames,
-    maxParallelImports,
-  );
+  const pairs = await importExtensions('driver', driverConfig, filteredDriverNames, maxParallelImports);
   return new Map(pairs as Array<[DriverClass, string]>);
 }
 
@@ -132,9 +119,7 @@ async function importExtensions(
       const timer = new timing.Timer().start();
       try {
         const extClass = await config.requireAsync(extName as never);
-        log.debug(
-          `${extClass.name} has been successfully loaded in ${timer.getDuration().asSeconds.toFixed(3)}s`,
-        );
+        log.debug(`${extClass.name} has been successfully loaded in ${timer.getDuration().asSeconds.toFixed(3)}s`);
         return extClass as ExtClass<ExtensionType>;
       } catch (err: any) {
         log.error(

package/lib/extension/manifest-migrations.ts

@@ -1,4 +1,5 @@
 import type {ManifestDataVersions} from 'appium/types';
+
 import {CURRENT_SCHEMA_REV, DRIVER_TYPE, PLUGIN_TYPE} from '../constants';
 import {log} from '../logger';
 import type {Manifest} from './manifest';

package/lib/extension/manifest.ts

@@ -1,17 +1,13 @@
-import {env, fs, util} from '@appium/support';
 import path from 'node:path';
-import * as YAML from 'yaml';
+
+import {env, fs, util} from '@appium/support';
 import type {DriverType, ExtensionType, PluginType} from '@appium/types';
-import type {
-  ExtManifest,
-  ExtPackageJson,
-  ExtRecord,
-  InternalMetadata,
-  ManifestData,
-} from 'appium/types';
+import type {ExtManifest, ExtPackageJson, ExtRecord, InternalMetadata, ManifestData} from 'appium/types';
+import * as YAML from 'yaml';
+
 import {CURRENT_SCHEMA_REV, DRIVER_TYPE, PLUGIN_TYPE} from '../constants';
-import {INSTALL_TYPE_DEV, INSTALL_TYPE_NPM} from './extension-config';
 import {packageDidChange} from '../utils';
+import {INSTALL_TYPE_DEV, INSTALL_TYPE_NPM} from './extension-config';
 import {migrate} from './manifest-migrations';
 
 const CONFIG_DATA_DRIVER_KEY = `${DRIVER_TYPE}s` as const;
@@ -120,9 +116,7 @@ export class Manifest {
         } else {
           throw new Error(
             `Appium had trouble loading the extension installation ` +
-              `cache file (${manifestPathResolved}). It may be invalid YAML. Specific error: ${
-                err.message
-              }`,
+              `cache file (${manifestPathResolved}). It may be invalid YAML. Specific error: ${err.message}`,
             {cause: err},
           );
         }
@@ -180,9 +174,7 @@ export class Manifest {
         return true;
       } catch (err: any) {
         throw new Error(
-          `Appium could not write to manifest at ${manifestPathResolved} using APPIUM_HOME ${
-            this.#appiumHome
-          }. Please ensure it is writable. Original error: ${err.message}`,
+          `Appium could not write to manifest at ${manifestPathResolved} using APPIUM_HOME ${this.#appiumHome}. Please ensure it is writable. Original error: ${err.message}`,
           {cause: err},
         );
       }
@@ -337,9 +329,7 @@ export class Manifest {
 
       if (path.relative(this.#appiumHome, resolved).startsWith('.')) {
         throw new Error(
-          `Mismatch between location of APPIUM_HOME and manifest file. APPIUM_HOME: ${
-            this.appiumHome
-          }, manifest file: ${resolved}`,
+          `Mismatch between location of APPIUM_HOME and manifest file. APPIUM_HOME: ${this.appiumHome}, manifest file: ${resolved}`,
         );
       }
     }

package/lib/extension/plugin-config.ts

@@ -1,6 +1,7 @@
 import {util} from '@appium/support';
 import type {PluginType} from '@appium/types';
 import type {ExtManifest, ExtName, ExtRecord} from 'appium/types';
+
 import {PLUGIN_TYPE} from '../constants';
 import {log} from '../logger';
 import {ExtensionConfig} from './extension-config';
@@ -32,10 +33,7 @@ export class PluginConfig extends ExtensionConfig<PluginType> {
     return await super._validate(this.manifest.getExtensionData(PLUGIN_TYPE));
   }
 
-  public override extensionDesc(
-    pluginName: ExtName<PluginType>,
-    {version}: ExtManifest<PluginType>,
-  ): string {
+  public override extensionDesc(pluginName: ExtName<PluginType>, {version}: ExtManifest<PluginType>): string {
     return `${String(pluginName)}@${version}`;
   }
 
@@ -44,8 +42,7 @@ export class PluginConfig extends ExtensionConfig<PluginType> {
 
     if (util.isEmpty(pluginNames)) {
       log.info(
-        `No plugins have been installed. Use the "appium plugin" ` +
-          'command to install the one(s) you want to use.',
+        `No plugins have been installed. Use the "appium plugin" ` + 'command to install the one(s) you want to use.',
       );
       return;
     }
@@ -53,15 +50,11 @@ export class PluginConfig extends ExtensionConfig<PluginType> {
     log.info(`Available plugins:`);
     for (const [pluginName, pluginData] of Object.entries(this.installedExtensions)) {
       const activeTxt = activeNames.includes(pluginName as ExtName<PluginType>) ? ' (ACTIVE)' : '';
-      log.info(
-        `  - ${this.extensionDesc(pluginName as ExtName<PluginType>, pluginData)}${activeTxt}`,
-      );
+      log.info(`  - ${this.extensionDesc(pluginName as ExtName<PluginType>, pluginData)}${activeTxt}`);
     }
 
     if (util.isEmpty(activeNames)) {
-      log.info(
-        'No plugins activated. Use the --use-plugins flag with names of plugins to activate',
-      );
+      log.info('No plugins activated. Use the --use-plugins flag with names of plugins to activate');
     }
   }
 }