appium 3.2.2 → 3.3.1

package/lib/extension/index.ts

@@ -0,0 +1,143 @@
+import _ from 'lodash';
+import B from 'bluebird';
+import type {DriverClass, ExtensionType, PluginClass} from '@appium/types';
+import type {ExtClass} from 'appium/types';
+import {USE_ALL_PLUGINS} from '../constants';
+import {log} from '../logger';
+import {DriverConfig} from './driver-config';
+import {Manifest} from './manifest';
+import {timing} from '@appium/support';
+import {PluginConfig} from './plugin-config';
+
+export type ExtensionConfigs = {
+  driverConfig: DriverConfig;
+  pluginConfig: PluginConfig;
+};
+
+export type PluginNameMap = Map<PluginClass, string>;
+export type DriverNameMap = Map<DriverClass, string>;
+
+/**
+ * Loads extensions and creates `ExtensionConfig` instances.
+ *
+ * - Reads the manifest file, creating if necessary
+ * - Using the parsed extension data, creates/gets the `ExtensionConfig` subclass instances
+ * - Returns these instances
+ *
+ * If `appiumHome` is needed, use `resolveAppiumHome` from the `env` module in `@appium/support`.
+ */
+export async function loadExtensions(appiumHome: string): Promise<ExtensionConfigs> {
+  const manifest = Manifest.getInstance(appiumHome);
+  await manifest.read();
+  const driverConfig = DriverConfig.getInstance(manifest) ?? DriverConfig.create(manifest);
+  const pluginConfig = PluginConfig.getInstance(manifest) ?? PluginConfig.create(manifest);
+
+  await B.all([driverConfig.validate(), pluginConfig.validate()]);
+  return {driverConfig, pluginConfig};
+}
+
+/**
+ * Find any plugin name which has been installed, and which has been requested for activation by
+ * using the --use-plugins flag, and turn each one into its class, so we can send them as objects
+ * to the server init. We also want to send/assign them to the umbrella driver so it can use them
+ * to wrap command execution
+ */
+export async function getActivePlugins(
+  pluginConfig: PluginConfig,
+  maxParallelImports: number,
+  usePlugins: string[] = []
+): Promise<PluginNameMap> {
+  if (_.isEmpty(usePlugins)) {
+    return new Map();
+  }
+
+  let filteredPluginNames: string[] = [];
+  if (usePlugins.length === 1 && usePlugins[0] === USE_ALL_PLUGINS) {
+    filteredPluginNames = _.keys(pluginConfig.installedExtensions);
+  } else {
+    for (const pluginName of usePlugins) {
+      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.`);
+      } else {
+        const suffix = _.isEmpty(pluginConfig.installedExtensions)
+          ? `You don't have any plugins installed yet.`
+          : `Only the following ${_.size(pluginConfig.installedExtensions) === 1 ? `plugin is` : `plugins are`} ` +
+            `available: ${_.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);
+  return new Map(pairs as Array<[PluginClass, string]>);
+}
+
+/**
+ * Find any driver name which has been installed, and turn each one into its class, so we can send
+ * them as objects to the server init in case they need to add methods/routes or update the server.
+ * If the --drivers flag was given, this method only loads the given drivers.
+ */
+export async function getActiveDrivers(
+  driverConfig: DriverConfig,
+  maxParallelImports: number,
+  useDrivers: string[] = []
+): Promise<DriverNameMap> {
+  let filteredDriverNames: string[] = [];
+  if (_.isEmpty(useDrivers)) {
+    filteredDriverNames = _.keys(driverConfig.installedExtensions);
+  } else {
+    for (const driverName of useDrivers) {
+      if (driverName in driverConfig.installedExtensions) {
+        filteredDriverNames.push(driverName);
+      } else {
+        const suffix = _.isEmpty(driverConfig.installedExtensions)
+          ? `You don't have any drivers installed yet.`
+          : `Only the following ${_.size(driverConfig.installedExtensions) === 1 ? `driver is` : `drivers are`} ` +
+            `available: ${_.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);
+  return new Map(pairs as Array<[DriverClass, string]>);
+}
+
+
+async function importExtensions(
+  extType: 'driver' | 'plugin',
+  config: DriverConfig | PluginConfig,
+  extNames: string[],
+  asyncImportChunkSize: number
+): Promise<Array<[ExtClass<ExtensionType>, string]>> {
+  const allPromises: Array<B<ExtClass<ExtensionType> | undefined>> = [];
+  const activePromisesChunk: Array<B<ExtClass<ExtensionType> | undefined>> = [];
+  for (const extName of extNames) {
+    _.remove(activePromisesChunk, (p) => p.isFulfilled());
+    if (activePromisesChunk.length >= asyncImportChunkSize) {
+      await B.any(activePromisesChunk);
+    }
+    const promise = B.resolve(
+      (async () => {
+        log.info(`Attempting to load ${extType} ${extName}...`);
+        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`);
+          return extClass as ExtClass<ExtensionType>;
+        } catch (err: any) {
+          log.error(
+            `Could not load ${extType} '${extName}', so it will not be available. Error ` +
+              `in loading the ${extType} was: ${err.message}`
+          );
+          log.debug(err.stack);
+        }
+      })()
+    );
+    activePromisesChunk.push(promise);
+    allPromises.push(promise);
+  }
+  return _.zip(await B.all(allPromises), extNames).filter(([extClass]) => Boolean(extClass)) as Array<
+    [ExtClass<ExtensionType>, string]
+  >;
+}

package/lib/extension/manifest-migrations.ts

@@ -0,0 +1,57 @@
+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';
+
+const SCHEMA_REV_3 = 3;
+const SCHEMA_REV_4 = 4;
+
+type Migration = (manifest: Manifest) => boolean | Promise<boolean>;
+
+const Migrations: Partial<Record<keyof ManifestDataVersions, Migration>> = {
+  [SCHEMA_REV_3]: (manifest) => {
+    const drivers = manifest.getExtensionData(DRIVER_TYPE);
+    const plugins = manifest.getExtensionData(PLUGIN_TYPE);
+    const allExtData = [...Object.values(drivers), ...Object.values(plugins)];
+    return allExtData.some((metadata) => !('installPath' in metadata));
+  },
+  [SCHEMA_REV_4]: (manifest) => {
+    if (manifest.schemaRev < SCHEMA_REV_4) {
+      const drivers = manifest.getExtensionData(DRIVER_TYPE);
+      const plugins = manifest.getExtensionData(PLUGIN_TYPE);
+      const allExtData = [...Object.values(drivers), ...Object.values(plugins)];
+      return allExtData.some((metadata) => metadata.installType === 'npm');
+    }
+    return false;
+  },
+};
+
+/**
+ * Applies a series of migration functions to a manifest to update its manifest schema version.
+ *
+ * `data` is modified in-place.
+ *
+ * @returns If `true` existing packages should be synced from disk and the manifest should be persisted.
+ */
+export async function migrate(manifest: Manifest): Promise<boolean> {
+  let didChange = false;
+  for (const migration of Object.values(Migrations)) {
+    if (migration) {
+      didChange = (await migration(manifest)) || didChange;
+    }
+  }
+  didChange = setSchemaRev(manifest, CURRENT_SCHEMA_REV) || didChange;
+  if (didChange) {
+    log.debug(`Upgraded extension manifest to schema v${manifest.schemaRev}`);
+  }
+
+  return didChange;
+}
+
+function setSchemaRev(manifest: Manifest, version: number): boolean {
+  if ((manifest.schemaRev ?? 0) < version) {
+    manifest.setSchemaRev(version);
+    return true;
+  }
+  return false;
+}

package/lib/extension/manifest.ts

@@ -0,0 +1,369 @@
+import B from 'bluebird';
+import {env, fs} from '@appium/support';
+import _ from 'lodash';
+import path from 'node:path';
+import * as YAML from 'yaml';
+import type {DriverType, ExtensionType, PluginType} from '@appium/types';
+import type {ExtManifest, ExtPackageJson, ExtRecord, InternalMetadata, ManifestData} from 'appium/types';
+import {CURRENT_SCHEMA_REV, DRIVER_TYPE, PLUGIN_TYPE} from '../constants';
+import {INSTALL_TYPE_DEV, INSTALL_TYPE_NPM} from './extension-config';
+import {packageDidChange} from './package-changed';
+import {migrate} from './manifest-migrations';
+
+const CONFIG_DATA_DRIVER_KEY = `${DRIVER_TYPE}s` as const;
+const CONFIG_DATA_PLUGIN_KEY = `${PLUGIN_TYPE}s` as const;
+
+const INITIAL_MANIFEST_DATA: Readonly<ManifestData> = Object.freeze({
+  [CONFIG_DATA_DRIVER_KEY]: Object.freeze({}),
+  [CONFIG_DATA_PLUGIN_KEY]: Object.freeze({}),
+  schemaRev: CURRENT_SCHEMA_REV,
+}) as Readonly<ManifestData>;
+
+/**
+ * Handles reading & writing of extension config files.
+ *
+ * Only one instance of this class exists per value of `APPIUM_HOME`.
+ */
+export class Manifest {
+  /**
+   * Returns the memoized manifest for an `APPIUM_HOME` directory (one instance per home).
+   *
+   * @param appiumHome - `APPIUM_HOME` path used as the cache key
+   */
+  static getInstance = _.memoize((appiumHome: string): Manifest => new Manifest(appiumHome));
+
+  #data!: ManifestData;
+  readonly #appiumHome: string;
+  #manifestPath: string | undefined = undefined;
+  #writing: Promise<boolean> | undefined;
+  #reading: Promise<void> | undefined;
+
+  private constructor(appiumHome: string) {
+    this.#appiumHome = appiumHome;
+    this.#data = _.cloneDeep(INITIAL_MANIFEST_DATA) as ManifestData;
+  }
+
+  /** `APPIUM_HOME` directory this manifest is tied to. */
+  get appiumHome(): string {
+    return this.#appiumHome;
+  }
+
+  /**
+   * Absolute path to the extension manifest file after {@link Manifest.read} or {@link Manifest.write} has resolved it.
+   * Before that, this is `undefined`.
+   */
+  get manifestPath(): string | undefined {
+    return this.#manifestPath;
+  }
+
+  /** Schema revision of the in-memory manifest data (from YAML `schemaRev`). */
+  get schemaRev(): number {
+    return this.#data.schemaRev;
+  }
+
+  /**
+   * Returns the live installed-extension map for drivers or plugins (same object as stored in memory).
+   * Mutations affect the manifest until replaced by a new object (e.g. via `read()`); `setExtension` / `deleteExtension` update this record.
+   *
+   * @param extType - `"driver"` or `"plugin"`
+   */
+  getExtensionData<ExtType extends ExtensionType>(extType: ExtType): ExtRecord<ExtType> {
+    const record = extType === DRIVER_TYPE ? this.#data.drivers : this.#data.plugins;
+    return record as ExtRecord<ExtType>;
+  }
+
+  /**
+   * Whether a driver with the given manifest key is present.
+   *
+   * @param name - Driver name as stored under `drivers` in the manifest
+   */
+  hasDriver(name: string): boolean {
+    return Boolean(this.#data.drivers[name]);
+  }
+
+  /**
+   * Whether a plugin with the given manifest key is present.
+   *
+   * @param name - Plugin name as stored under `plugins` in the manifest
+   */
+  hasPlugin(name: string): boolean {
+    return Boolean(this.#data.plugins[name]);
+  }
+
+  /**
+   * Loads manifest YAML from disk into memory, runs migration when needed, may sync with installed packages, and writes back if required.
+   * Concurrent calls while a read is in flight share the same in-flight work.
+   *
+   * @returns The parsed in-memory manifest data
+   */
+  async read(): Promise<ManifestData> {
+    if (this.#reading) {
+      await this.#reading;
+      return this.#data;
+    }
+
+    this.#reading = (async () => {
+      let data: ManifestData;
+      let shouldWrite = false;
+      const manifestPathResolved = await this.#setManifestPath();
+      try {
+        const yaml = await fs.readFile(manifestPathResolved, 'utf8');
+        data = YAML.parse(yaml) as ManifestData;
+      } catch (err: any) {
+        if (err.code === 'ENOENT') {
+          data = _.cloneDeep(INITIAL_MANIFEST_DATA) as ManifestData;
+          shouldWrite = true;
+        } else {
+          throw new Error(
+            `Appium had trouble loading the extension installation ` +
+              `cache file (${manifestPathResolved}). It may be invalid YAML. Specific error: ${
+                err.message
+              }`
+          );
+        }
+      }
+
+      this.#data = data;
+
+      if (!shouldWrite && (data.schemaRev ?? 0) < CURRENT_SCHEMA_REV) {
+        shouldWrite = await migrate(this);
+      }
+
+      const hasAppiumDependency = await env.hasAppiumDependency(this.appiumHome);
+
+      if (shouldWrite || (hasAppiumDependency && (await packageDidChange(this.appiumHome)))) {
+        shouldWrite = (await this.syncWithInstalledExtensions(hasAppiumDependency)) || shouldWrite;
+      }
+
+      if (shouldWrite) {
+        await this.write();
+      }
+    })();
+
+    try {
+      await this.#reading;
+      return this.#data;
+    } finally {
+      this.#reading = undefined;
+    }
+  }
+
+  /**
+   * Serializes the current in-memory manifest to the resolved manifest path.
+   * Concurrent calls while a write is in flight share the same in-flight work.
+   *
+   * @returns `true` when the file was written successfully
+   */
+  async write(): Promise<boolean> {
+    if (this.#writing) {
+      return this.#writing;
+    }
+    this.#writing = (async () => {
+      const manifestPathResolved = await this.#setManifestPath();
+      try {
+        await fs.mkdirp(path.dirname(manifestPathResolved));
+      } catch (err: any) {
+        throw new Error(
+          `Appium could not create the directory for the manifest file: ${path.dirname(
+            manifestPathResolved
+          )}. Original error: ${err.message}`
+        );
+      }
+      try {
+        await fs.writeFile(manifestPathResolved, YAML.stringify(this.#data), 'utf8');
+        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}`
+        );
+      }
+    })();
+    try {
+      return await this.#writing;
+    } finally {
+      this.#writing = undefined;
+    }
+  }
+
+  /**
+   * Scans `APPIUM_HOME` (root and `node_modules`) for Appium extension packages and merges them into the manifest.
+   *
+   * @param hasAppiumDependency - When true and the root `package.json` depends on Appium, matching extensions use the `"dev"` install type
+   * @returns `true` if any extension entries changed, `false` otherwise
+   */
+  async syncWithInstalledExtensions(hasAppiumDependency = false): Promise<boolean> {
+    let didChange = false;
+
+    const onMatch = async (filepath: string, devType = false): Promise<void> => {
+      try {
+        const pkg = JSON.parse(await fs.readFile(filepath, 'utf8')) as unknown;
+        if (isExtension(pkg)) {
+          const installType = devType && hasAppiumDependency ? INSTALL_TYPE_DEV : INSTALL_TYPE_NPM;
+          const changed = this.addExtensionFromPackage(pkg, filepath, installType);
+          didChange = didChange || changed;
+        }
+      } catch {
+        // ignore invalid package.json
+      }
+    };
+
+    const queue: Promise<void>[] = [
+      onMatch(path.join(this.#appiumHome, 'package.json'), true),
+    ];
+
+    const filepaths = await fs.glob('node_modules/{*,@*/*}/package.json', {
+      cwd: this.#appiumHome,
+      absolute: true,
+    });
+    for (const filepath of filepaths) {
+      queue.push(onMatch(filepath));
+    }
+
+    await B.all(queue);
+
+    return didChange;
+  }
+
+  /**
+   * Builds manifest metadata from a `package.json` and registers it if it is a driver or plugin and the entry changed.
+   *
+   * @param pkgJson - Parsed extension `package.json`
+   * @param pkgPath - Path to that `package.json` (install path is derived from its directory)
+   * @param installType - How the package was discovered (`npm` vs `dev`)
+   * @returns `true` if the manifest was updated, `false` if unchanged or already matched
+   * @throws TypeError if the package is not a valid driver or plugin extension
+   */
+  addExtensionFromPackage(
+    pkgJson: ExtPackageJson<ExtensionType>,
+    pkgPath: string,
+    installType: typeof INSTALL_TYPE_NPM | typeof INSTALL_TYPE_DEV = INSTALL_TYPE_NPM
+  ): boolean {
+    const extensionPath = path.dirname(pkgPath);
+
+    const internal: InternalMetadata = {
+      pkgName: pkgJson.name,
+      version: pkgJson.version,
+      appiumVersion: pkgJson.peerDependencies?.appium,
+      installType,
+      installSpec: `${pkgJson.name}@${pkgJson.version}`,
+      installPath: extensionPath,
+    };
+
+    if (isDriver(pkgJson)) {
+      const driverName = pkgJson.appium.driverName;
+      const value = {
+        ..._.omit(pkgJson.appium, 'driverName'),
+        ...internal,
+      };
+      if (!_.isEqual(value, this.#data.drivers[driverName])) {
+        this.setExtension(DRIVER_TYPE, driverName, value);
+        return true;
+      }
+      return false;
+    }
+    if (isPlugin(pkgJson)) {
+      const pluginName = pkgJson.appium.pluginName;
+      const value = {
+        ..._.omit(pkgJson.appium, 'pluginName'),
+        ...internal,
+      };
+      if (!_.isEqual(value, this.#data.plugins[pluginName])) {
+        this.setExtension(PLUGIN_TYPE, pluginName, value);
+        return true;
+      }
+      return false;
+    }
+    throw new TypeError(
+      `The extension in ${extensionPath} is neither a valid ${DRIVER_TYPE} nor a valid ${PLUGIN_TYPE}.`
+    );
+  }
+
+  /**
+   * Stores a deep-cloned copy of extension metadata under the given type and name.
+   *
+   * @param extType - `"driver"` or `"plugin"`
+   * @param extName - Manifest key for the extension
+   * @param extData - Full extension entry to persist in memory
+   * @returns The cloned data now held in the manifest
+   */
+  setExtension<ExtType extends ExtensionType>(
+    extType: ExtType,
+    extName: string,
+    extData: ExtManifest<ExtType>
+  ): ExtManifest<ExtType> {
+    const data = _.cloneDeep(extData) as ExtManifest<ExtType>;
+    if (extType === DRIVER_TYPE) {
+      this.#data.drivers[extName] = data as unknown as ExtManifest<DriverType>;
+    } else {
+      this.#data.plugins[extName] = data as unknown as ExtManifest<PluginType>;
+    }
+    return data;
+  }
+
+  /**
+   * Updates the in-memory manifest schema revision (typically during migration).
+   *
+   * @param rev - New `schemaRev` value
+   */
+  setSchemaRev(rev: number): void {
+    this.#data.schemaRev = rev;
+  }
+
+  /**
+   * Removes an extension entry from the manifest data in memory (does not write to disk by itself).
+   *
+   * @param extType - `"driver"` or `"plugin"`
+   * @param extName - Manifest key to remove
+   */
+  deleteExtension(extType: ExtensionType, extName: string): void {
+    if (extType === DRIVER_TYPE) {
+      delete this.#data.drivers[extName];
+    } else {
+      delete this.#data.plugins[extName];
+    }
+  }
+
+  async #setManifestPath(): Promise<string> {
+    if (!this.#manifestPath) {
+      const resolved = await env.resolveManifestPath(this.#appiumHome);
+      this.#manifestPath = resolved;
+
+      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}`
+        );
+      }
+    }
+
+    return this.#manifestPath;
+  }
+}
+
+function isExtension(value: unknown): value is ExtPackageJson<ExtensionType> {
+  return (
+    _.isPlainObject(value) &&
+    _.isPlainObject((value as {appium?: unknown}).appium) &&
+    _.isString((value as {name?: unknown}).name) &&
+    _.isString((value as {version?: unknown}).version)
+  );
+}
+
+function isDriver(value: unknown): value is ExtPackageJson<DriverType> {
+  return (
+    isExtension(value) &&
+    'driverName' in value.appium &&
+    _.isString((value.appium as {driverName?: unknown}).driverName)
+  );
+}
+
+function isPlugin(value: unknown): value is ExtPackageJson<PluginType> {
+  return (
+    isExtension(value) &&
+    'pluginName' in value.appium &&
+    _.isString((value.appium as {pluginName?: unknown}).pluginName)
+  );
+}

package/lib/extension/{package-changed.js → package-changed.ts}

@@ -2,7 +2,7 @@ import {fs} from '@appium/support';
 import {isPackageChanged} from 'package-changed';
 import path from 'node:path';
 import {PKG_HASHFILE_RELATIVE_PATH} from '../constants';
-import log from '../logger';
+import {log} from '../logger';
 
 /**
  * Determines if extensions have changed, and updates a hash the `package.json` in `appiumHome` if so.
@@ -10,40 +10,31 @@ import log from '../logger';
  * If they have, we need to sync them with the `extensions.yaml` manifest.
  *
  * _Warning: this makes a blocking call to `writeFileSync`._
- * @param {string} appiumHome
- * @returns {Promise<boolean>} `true` if `package.json` `appiumHome` changed
  */
-export async function packageDidChange(appiumHome) {
+export async function packageDidChange(appiumHome: string): Promise<boolean> {
   const hashFilename = path.join(appiumHome, PKG_HASHFILE_RELATIVE_PATH);
 
-  // XXX: the types in `package-changed` seem to be wrong.
-
-  /** @type {boolean} */
-  let isChanged;
-  /** @type {() => void} */
-  let writeHash;
-  /** @type {string} */
-  let hash;
-  /** @type {string|undefined} */
-  let oldHash;
-
-  // first mkdirp the target dir.
   const hashFilenameDir = path.dirname(hashFilename);
   log.debug(`Creating hash file directory: ${hashFilenameDir}`);
   try {
     await fs.mkdirp(hashFilenameDir);
-  } catch (err) {
+  } catch (err: any) {
     throw new Error(
       `Appium could not create the directory for hash file: ${hashFilenameDir}. Original error: ${err.message}`
     );
   }
 
+  let isChanged: boolean;
+  let writeHash: () => void;
+  let oldHash: string | undefined;
+  let hash: string;
   try {
     ({isChanged, writeHash, oldHash, hash} = await isPackageChanged({
       cwd: appiumHome,
       hashFilename: PKG_HASHFILE_RELATIVE_PATH,
     }));
   } catch {
+    // If the library fails, assume the manifest may be stale and should be refreshed.
     return true;
   }
 
@@ -53,7 +44,7 @@ export async function packageDidChange(appiumHome) {
       log.debug(
         `Updated hash of ${appiumHome}/package.json from: ${oldHash ?? '(none)'} to: ${hash}`
       );
-    } catch (err) {
+    } catch (err: any) {
       throw new Error(
         `Appium could not write hash file: ${hashFilenameDir}. Original error: ${err.message}`
       );

package/lib/extension/plugin-config.ts

@@ -0,0 +1,62 @@
+import _ from 'lodash';
+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';
+import type {Manifest} from './manifest';
+
+export class PluginConfig extends ExtensionConfig<PluginType> {
+  private static readonly _instances = new WeakMap<Manifest, PluginConfig>();
+
+  private constructor(manifest: Manifest) {
+    super(PLUGIN_TYPE, manifest);
+  }
+
+  static create(manifest: Manifest): PluginConfig {
+    const instance = new PluginConfig(manifest);
+    if (PluginConfig.getInstance(manifest)) {
+      throw new Error(
+        `Manifest with APPIUM_HOME ${manifest.appiumHome} already has a PluginConfig; use PluginConfig.getInstance() to retrieve it.`
+      );
+    }
+    PluginConfig._instances.set(manifest, instance);
+    return instance;
+  }
+
+  static getInstance(manifest: Manifest): PluginConfig | undefined {
+    return PluginConfig._instances.get(manifest);
+  }
+
+  async validate(): Promise<ExtRecord<PluginType>> {
+    return await super._validate(this.manifest.getExtensionData(PLUGIN_TYPE));
+  }
+
+  public override extensionDesc(
+    pluginName: ExtName<PluginType>,
+    {version}: ExtManifest<PluginType>
+  ): string {
+    return `${String(pluginName)}@${version}`;
+  }
+
+  override print(activeNames: ExtName<PluginType>[] = []): void {
+    const pluginNames = Object.keys(this.installedExtensions);
+
+    if (_.isEmpty(pluginNames)) {
+      log.info(
+        `No plugins have been installed. Use the "appium plugin" ` + 'command to install the one(s) you want to use.'
+      );
+      return;
+    }
+
+    log.info(`Available plugins:`);
+    for (const [pluginName, pluginData] of _.toPairs(this.installedExtensions)) {
+      const activeTxt = _.includes(activeNames, pluginName as ExtName<PluginType>) ? ' (ACTIVE)' : '';
+      log.info(`  - ${this.extensionDesc(pluginName as ExtName<PluginType>, pluginData)}${activeTxt}`);
+    }
+
+    if (_.isEmpty(activeNames)) {
+      log.info('No plugins activated. Use the --use-plugins flag with names of plugins to activate');
+    }
+  }
+}