appium 2.0.0-beta.4 → 2.0.0-beta.40

package/build/lib/extension/index.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getActiveDrivers = getActiveDrivers;
+exports.getActivePlugins = getActivePlugins;
+exports.loadExtensions = loadExtensions;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _constants = require("../constants");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var _driverConfig = require("./driver-config");
+
+var _manifest = require("./manifest");
+
+var _pluginConfig = require("./plugin-config");
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+async function loadExtensions(appiumHome) {
+  var _DriverConfig$getInst, _PluginConfig$getInst;
+
+  const manifest = _manifest.Manifest.getInstance(appiumHome);
+
+  await manifest.read();
+  const driverConfig = (_DriverConfig$getInst = _driverConfig.DriverConfig.getInstance(manifest)) !== null && _DriverConfig$getInst !== void 0 ? _DriverConfig$getInst : _driverConfig.DriverConfig.create(manifest);
+  const pluginConfig = (_PluginConfig$getInst = _pluginConfig.PluginConfig.getInstance(manifest)) !== null && _PluginConfig$getInst !== void 0 ? _PluginConfig$getInst : _pluginConfig.PluginConfig.create(manifest);
+  await _bluebird.default.all([driverConfig.validate(), pluginConfig.validate()]);
+  return {
+    driverConfig,
+    pluginConfig
+  };
+}
+
+function getActivePlugins(pluginConfig, usePlugins = []) {
+  return new Map(_lodash.default.compact(Object.keys(pluginConfig.installedExtensions).filter(pluginName => _lodash.default.includes(usePlugins, pluginName) || usePlugins.length === 1 && usePlugins[0] === _constants.USE_ALL_PLUGINS).map(pluginName => {
+    try {
+      _logger.default.info(`Attempting to load plugin ${pluginName}...`);
+
+      const PluginClass = pluginConfig.require(pluginName);
+
+      return [PluginClass, pluginName];
+    } catch (err) {
+      _logger.default.error(`Could not load plugin '${pluginName}', so it will not be available. Error ` + `in loading the plugin was: ${err.message}`);
+
+      _logger.default.debug(err.stack);
+    }
+  })));
+}
+
+function getActiveDrivers(driverConfig, useDrivers = []) {
+  return new Map(_lodash.default.compact(Object.keys(driverConfig.installedExtensions).filter(driverName => _lodash.default.includes(useDrivers, driverName) || useDrivers.length === 0).map(driverName => {
+    try {
+      _logger.default.info(`Attempting to load driver ${driverName}...`);
+
+      const DriverClass = driverConfig.require(driverName);
+
+      return [DriverClass, driverName];
+    } catch (err) {
+      _logger.default.error(`Could not load driver '${driverName}', so it will not be available. Error ` + `in loading the driver was: ${err.message}`);
+
+      _logger.default.debug(err.stack);
+    }
+  })));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["loadExtensions","appiumHome","manifest","Manifest","getInstance","read","driverConfig","DriverConfig","create","pluginConfig","PluginConfig","B","all","validate","getActivePlugins","usePlugins","Map","_","compact","Object","keys","installedExtensions","filter","pluginName","includes","length","USE_ALL_PLUGINS","map","log","info","PluginClass","require","err","error","message","debug","stack","getActiveDrivers","useDrivers","driverName","DriverClass"],"sources":["../../../lib/extension/index.js"],"sourcesContent":["import _ from 'lodash';\nimport {USE_ALL_PLUGINS} from '../constants';\nimport log from '../logger';\nimport {DriverConfig} from './driver-config';\nimport {Manifest} from './manifest';\nimport {PluginConfig} from './plugin-config';\nimport B from 'bluebird';\n\n/**\n * Loads extensions and creates `ExtensionConfig` instances.\n *\n * - Reads the manifest file, creating if necessary\n * - Using the parsed extension data, creates/gets the `ExtensionConfig` subclass instances\n * - Returns these instances\n *\n * If `appiumHome` is needed, use `resolveAppiumHome` from the `env` module in `@appium/support`.\n * @param {string} appiumHome\n * @returns {Promise<ExtensionConfigs>}\n */\nexport async function loadExtensions(appiumHome) {\n  const manifest = Manifest.getInstance(appiumHome);\n  await manifest.read();\n  const driverConfig = DriverConfig.getInstance(manifest) ?? DriverConfig.create(manifest);\n  const pluginConfig = PluginConfig.getInstance(manifest) ?? PluginConfig.create(manifest);\n\n  await B.all([driverConfig.validate(), pluginConfig.validate()]);\n  return {driverConfig, pluginConfig};\n}\n\n/**\n * Find any plugin name which has been installed, and which has been requested for activation by\n * using the --use-plugins flag, and turn each one into its class, so we can send them as objects\n * to the server init. We also want to send/assign them to the umbrella driver so it can use them\n * to wrap command execution\n *\n * @param {import('./plugin-config').PluginConfig} pluginConfig - a plugin extension config\n * @param {string[]} usePlugins\n * @returns {PluginNameMap} Mapping of PluginClass to name\n */\nexport function getActivePlugins(pluginConfig, usePlugins = []) {\n  return new Map(\n    _.compact(\n      Object.keys(pluginConfig.installedExtensions)\n        .filter(\n          (pluginName) =>\n            _.includes(usePlugins, pluginName) ||\n            (usePlugins.length === 1 && usePlugins[0] === USE_ALL_PLUGINS)\n        )\n        .map((pluginName) => {\n          try {\n            log.info(`Attempting to load plugin ${pluginName}...`);\n            const PluginClass = pluginConfig.require(pluginName);\n            return [PluginClass, pluginName];\n          } catch (err) {\n            log.error(\n              `Could not load plugin '${pluginName}', so it will not be available. Error ` +\n                `in loading the plugin was: ${err.message}`\n            );\n            log.debug(err.stack);\n          }\n        })\n    )\n  );\n}\n\n/**\n * Find any driver name which has been installed, and turn each one into its class, so we can send\n * them as objects to the server init in case they need to add methods/routes or update the server.\n * If the --drivers flag was given, this method only loads the given drivers.\n *\n * @param {import('./driver-config').DriverConfig} driverConfig - a driver extension config\n * @param {string[]} [useDrivers] - optional list of drivers to load\n * @returns {DriverNameMap}\n */\nexport function getActiveDrivers(driverConfig, useDrivers = []) {\n  return new Map(\n    _.compact(\n      Object.keys(driverConfig.installedExtensions)\n        .filter((driverName) => _.includes(useDrivers, driverName) || useDrivers.length === 0)\n        .map((driverName) => {\n          try {\n            log.info(`Attempting to load driver ${driverName}...`);\n            const DriverClass = driverConfig.require(driverName);\n            return [DriverClass, driverName];\n          } catch (err) {\n            log.error(\n              `Could not load driver '${driverName}', so it will not be available. Error ` +\n                `in loading the driver was: ${err.message}`\n            );\n            log.debug(err.stack);\n          }\n        })\n    )\n  );\n}\n\n/**\n * A mapping of {@linkcode PluginClass} classes to their names.\n * @typedef {Map<PluginClass,string>} PluginNameMap\n */\n\n/**\n * A mapping of {@linkcode DriverClass} classes to their names.\n * @typedef {Map<DriverClass,string>} DriverNameMap\n */\n\n/**\n * @typedef {import('@appium/types').PluginClass} PluginClass\n * @typedef {import('@appium/types').DriverClass} DriverClass\n */\n\n/**\n * @typedef ExtensionConfigs\n * @property {import('./driver-config').DriverConfig} driverConfig\n * @property {import('./plugin-config').PluginConfig} pluginConfig\n */\n"],"mappings":";;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAaO,eAAeA,cAAf,CAA8BC,UAA9B,EAA0C;EAAA;;EAC/C,MAAMC,QAAQ,GAAGC,kBAAA,CAASC,WAAT,CAAqBH,UAArB,CAAjB;;EACA,MAAMC,QAAQ,CAACG,IAAT,EAAN;EACA,MAAMC,YAAY,4BAAGC,0BAAA,CAAaH,WAAb,CAAyBF,QAAzB,CAAH,yEAAyCK,0BAAA,CAAaC,MAAb,CAAoBN,QAApB,CAA3D;EACA,MAAMO,YAAY,4BAAGC,0BAAA,CAAaN,WAAb,CAAyBF,QAAzB,CAAH,yEAAyCQ,0BAAA,CAAaF,MAAb,CAAoBN,QAApB,CAA3D;EAEA,MAAMS,iBAAA,CAAEC,GAAF,CAAM,CAACN,YAAY,CAACO,QAAb,EAAD,EAA0BJ,YAAY,CAACI,QAAb,EAA1B,CAAN,CAAN;EACA,OAAO;IAACP,YAAD;IAAeG;EAAf,CAAP;AACD;;AAYM,SAASK,gBAAT,CAA0BL,YAA1B,EAAwCM,UAAU,GAAG,EAArD,EAAyD;EAC9D,OAAO,IAAIC,GAAJ,CACLC,eAAA,CAAEC,OAAF,CACEC,MAAM,CAACC,IAAP,CAAYX,YAAY,CAACY,mBAAzB,EACGC,MADH,CAEKC,UAAD,IACEN,eAAA,CAAEO,QAAF,CAAWT,UAAX,EAAuBQ,UAAvB,KACCR,UAAU,CAACU,MAAX,KAAsB,CAAtB,IAA2BV,UAAU,CAAC,CAAD,CAAV,KAAkBW,0BAJpD,EAMGC,GANH,CAMQJ,UAAD,IAAgB;IACnB,IAAI;MACFK,eAAA,CAAIC,IAAJ,CAAU,6BAA4BN,UAAW,KAAjD;;MACA,MAAMO,WAAW,GAAGrB,YAAY,CAACsB,OAAb,CAAqBR,UAArB,CAApB;;MACA,OAAO,CAACO,WAAD,EAAcP,UAAd,CAAP;IACD,CAJD,CAIE,OAAOS,GAAP,EAAY;MACZJ,eAAA,CAAIK,KAAJ,CACG,0BAAyBV,UAAW,wCAArC,GACG,8BAA6BS,GAAG,CAACE,OAAQ,EAF9C;;MAIAN,eAAA,CAAIO,KAAJ,CAAUH,GAAG,CAACI,KAAd;IACD;EACF,CAlBH,CADF,CADK,CAAP;AAuBD;;AAWM,SAASC,gBAAT,CAA0B/B,YAA1B,EAAwCgC,UAAU,GAAG,EAArD,EAAyD;EAC9D,OAAO,IAAItB,GAAJ,CACLC,eAAA,CAAEC,OAAF,CACEC,MAAM,CAACC,IAAP,CAAYd,YAAY,CAACe,mBAAzB,EACGC,MADH,CACWiB,UAAD,IAAgBtB,eAAA,CAAEO,QAAF,CAAWc,UAAX,EAAuBC,UAAvB,KAAsCD,UAAU,CAACb,MAAX,KAAsB,CADtF,EAEGE,GAFH,CAEQY,UAAD,IAAgB;IACnB,IAAI;MACFX,eAAA,CAAIC,IAAJ,CAAU,6BAA4BU,UAAW,KAAjD;;MACA,MAAMC,WAAW,GAAGlC,YAAY,CAACyB,OAAb,CAAqBQ,UAArB,CAApB;;MACA,OAAO,CAACC,WAAD,EAAcD,UAAd,CAAP;IACD,CAJD,CAIE,OAAOP,GAAP,EAAY;MACZJ,eAAA,CAAIK,KAAJ,CACG,0BAAyBM,UAAW,wCAArC,GACG,8BAA6BP,GAAG,CAACE,OAAQ,EAF9C;;MAIAN,eAAA,CAAIO,KAAJ,CAAUH,GAAG,CAACI,KAAd;IACD;EACF,CAdH,CADF,CADK,CAAP;AAmBD"}

package/build/lib/extension/manifest.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Handles reading & writing of extension config files.
+ *
+ * Only one instance of this class exists per value of `APPIUM_HOME`.
+ */
+export class Manifest {
+    /**
+     * Returns a new or existing {@link Manifest} instance, based on the value of `appiumHome`.
+     *
+     * Maintains one instance per value of `appiumHome`.
+     * @param {string} appiumHome - Path to `APPIUM_HOME`
+     * @returns {Manifest}
+     */
+    static getInstance: ((appiumHome: any) => Manifest) & _.MemoizedFunction;
+    /**
+     * Sets internal data to a fresh clone of {@link INITIAL_MANIFEST_DATA}
+     *
+     * Use {@link Manifest.getInstance} instead.
+     * @param {string} appiumHome
+     * @private
+     */
+    private constructor();
+    /**
+     * The entire contents of a parsed YAML extension config file.
+     *
+     * Contains proxies for automatic persistence on disk
+     * @type {ManifestData}
+     * @private
+     */
+    private _data;
+    /**
+     * Path to `APPIUM_HOME`.
+     * @private
+     * @type {Readonly<string>}
+     */
+    private _appiumHome;
+    /**
+     * Path to `extensions.yaml`
+     * @type {string}
+     * Not set until {@link Manifest.read} is called.
+     */
+    _manifestPath: string;
+    /**
+     * Helps avoid writing multiple times.
+     *
+     * If this is `undefined`, calling {@link Manifest.write} will cause it to be
+     * set to a `Promise`. When the call to `write()` is complete, the `Promise`
+     * will resolve and then this value will be set to `undefined`.  Concurrent calls
+     * made while this value is a `Promise` will return the `Promise` itself.
+     * @private
+     * @type {Promise<boolean>|undefined}
+     */
+    private _writing;
+    /**
+     * Helps avoid reading multiple times.
+     *
+     * If this is `undefined`, calling {@link Manifest.read} will cause it to be
+     * set to a `Promise`. When the call to `read()` is complete, the `Promise`
+     * will resolve and then this value will be set to `undefined`.  Concurrent calls
+     * made while this value is a `Promise` will return the `Promise` itself.
+     * @private
+     * @type {Promise<void>|undefined}
+     */
+    private _reading;
+    /**
+     * Searches `APPIUM_HOME` for installed extensions and adds them to the manifest.
+     * @param {SyncWithInstalledExtensionsOpts} opts
+     * @returns {Promise<boolean>} `true` if any extensions were added, `false` otherwise.
+     */
+    syncWithInstalledExtensions({ depthLimit }?: SyncWithInstalledExtensionsOpts): Promise<boolean>;
+    /**
+     * Returns `true` if driver with name `name` is registered.
+     * @param {string} name - Driver name
+     * @returns {boolean}
+     */
+    hasDriver(name: string): boolean;
+    /**
+     * Returns `true` if plugin with name `name` is registered.
+     * @param {string} name - Plugin name
+     * @returns {boolean}
+     */
+    hasPlugin(name: string): boolean;
+    /**
+     * Given a path to a `package.json`, add it as either a driver or plugin to the manifest.
+     *
+     * Will _not_ overwrite existing entries.
+     * @template {ExtensionType} ExtType
+     * @param {ExtPackageJson<ExtType>} pkgJson
+     * @param {string} pkgPath
+     * @returns {boolean} - `true` upon success, `false` if the extension is already registered.
+     */
+    addExtensionFromPackage<ExtType extends import("@appium/types").ExtensionType>(pkgJson: ExtPackageJson<ExtType>, pkgPath: string): boolean;
+    /**
+     * Adds an extension to the manifest as was installed by the `appium` CLI.  The
+     * `extData`, `extType`, and `extName` have already been determined.
+     *
+     * See {@link Manifest.addExtensionFromPackage} for adding an extension from an on-disk package.
+     * @template {ExtensionType} ExtType
+     * @param {ExtType} extType - `driver` or `plugin`
+     * @param {string} extName - Name of extension
+     * @param {ExtManifest<ExtType>} extData - Extension metadata
+     * @returns {ExtManifest<ExtType>} A clone of `extData`, potentially with a mutated `appiumVersion` field
+     */
+    addExtension<ExtType_1 extends import("@appium/types").ExtensionType>(extType: ExtType_1, extName: string, extData: ExtManifest<ExtType_1>): ExtManifest<ExtType_1>;
+    /**
+     * Returns the APPIUM_HOME path
+     */
+    get appiumHome(): string;
+    /**
+     * Returns the path to the manifest file
+     */
+    get manifestPath(): string;
+    /**
+     * Returns extension data for a particular type.
+     *
+     * @template {ExtensionType} ExtType
+     * @param {ExtType} extType
+     * @returns {ExtRecord<ExtType>}
+     */
+    getExtensionData<ExtType_2 extends import("@appium/types").ExtensionType>(extType: ExtType_2): ExtRecord<ExtType_2>;
+    /**
+     * Reads manifest from disk and _overwrites_ the internal data.
+     *
+     * If the manifest does not exist on disk, an {@link INITIAL_MANIFEST_DATA "empty"} manifest file will be created.
+     *
+     * If `APPIUM_HOME` contains a `package.json` with an `appium` dependency, then a hash of the `package.json` will be taken. If this hash differs from the last hash, the contents of `APPIUM_HOME/node_modules` will be scanned for extensions that may have been installed outside of the `appium` CLI.  Any found extensions will be added to the manifest file, and if so, the manifest file will be written to disk.
+     *
+     * Only one read operation should happen at a time.  This is controlled via the {@link Manifest._reading} property.
+     * @returns {Promise<ManifestData>} The data
+     */
+    read(): Promise<ManifestData>;
+    /**
+     * Ensures {@link Manifest._manifestPath} is set.
+     *
+     * Creates the directory if necessary.
+     * @private
+     * @returns {Promise<string>}
+     */
+    private _setManifestPath;
+    /**
+     * Writes the data if it need s writing.
+     *
+     * If the `schemaRev` prop needs updating, the file will be written.
+     *
+     * @todo If this becomes too much of a bottleneck, throttle it.
+     * @returns {Promise<boolean>} Whether the data was written
+     */
+    write(): Promise<boolean>;
+}
+/**
+ * Type of the string referring to a driver (typically as a key or type string)
+ */
+export type DriverType = import('@appium/types').DriverType;
+/**
+ * Type of the string referring to a plugin (typically as a key or type string)
+ */
+export type PluginType = import('@appium/types').PluginType;
+export type SyncWithInstalledExtensionsOpts = {
+    /**
+     * - Maximum depth to recurse into subdirectories
+     */
+    depthLimit?: number | undefined;
+};
+export type ManifestData = import('appium/types').ManifestData;
+export type InternalMetadata = import('appium/types').InternalMetadata;
+export type ExtPackageJson<T> = import('appium/types').ExtPackageJson<T>;
+export type ExtManifest<T> = import('appium/types').ExtManifest<T>;
+export type ExtRecord<T> = import('appium/types').ExtRecord<T>;
+/**
+ * Either `driver` or `plugin` rn
+ */
+export type ExtensionType = import('@appium/types').ExtensionType;
+import _ from "lodash";
+//# sourceMappingURL=manifest.d.ts.map

package/build/lib/extension/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../lib/extension/manifest.js"],"names":[],"mappings":"AAmGA;;;;GAIG;AACH;IA4DE;;;;;;OAMG;IACH,yEAEG;IArBH;;;;;;OAMG;IACH,sBAGC;IAzDD;;;;;;OAMG;IACH,cAAM;IAEN;;;;OAIG;IACH,oBAAY;IAEZ;;;;OAIG;IACH,eAHU,MAAM,CAGF;IAEd;;;;;;;;;OASG;IACH,iBAAS;IAET;;;;;;;;;OASG;IACH,iBAAS;IAyBT;;;;OAIG;IACH,6CAHW,+BAA+B,GAC7B,QAAQ,OAAO,CAAC,CAoB5B;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,0HAHW,MAAM,GACJ,OAAO,CAuCnB;IAED;;;;;;;;;;OAUG;IACH,mGAJW,MAAM,2DAQhB;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;;;OAMG;IACH,oHAEC;IAED;;;;;;;;;OASG;IACH,QAFa,QAAQ,YAAY,CAAC,CAuDjC;IAED;;;;;;OAMG;IACH,yBAaC;IAED;;;;;;;OAOG;IACH,SAFa,QAAQ,OAAO,CAAC,CAgC5B;CACF;;;;yBAIY,OAAO,eAAe,EAAE,UAAU;;;;yBAKlC,OAAO,eAAe,EAAE,UAAU;;;;;;;2BASlC,OAAO,cAAc,EAAE,YAAY;+BACnC,OAAO,cAAc,EAAE,gBAAgB;gCAKvC,OAAO,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC;6BAKxC,OAAO,cAAc,EAAE,WAAW,CAAC,CAAC,CAAC;2BAKrC,OAAO,cAAc,EAAE,SAAS,CAAC,CAAC,CAAC;;;;4BAKnC,OAAO,eAAe,EAAE,aAAa"}

package/build/lib/extension/manifest.js

@@ -0,0 +1,256 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Manifest = void 0;
+
+require("source-map-support/register");
+
+var _support = require("@appium/support");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _yaml = _interopRequireDefault(require("yaml"));
+
+var _constants = require("../constants");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var _extensionConfig = require("./extension-config");
+
+var _packageChanged = require("./package-changed");
+
+const DEFAULT_SEARCH_DEPTH = 4;
+const DEFAULT_FIND_EXTENSIONS_OPTS = Object.freeze({
+  depthLimit: DEFAULT_SEARCH_DEPTH,
+  filter: filepath => !_path.default.basename(filepath).startsWith('.')
+});
+const CONFIG_SCHEMA_REV = 2;
+const CONFIG_DATA_DRIVER_KEY = `${_constants.DRIVER_TYPE}s`;
+const CONFIG_DATA_PLUGIN_KEY = `${_constants.PLUGIN_TYPE}s`;
+const INITIAL_MANIFEST_DATA = Object.freeze({
+  [CONFIG_DATA_DRIVER_KEY]: Object.freeze({}),
+  [CONFIG_DATA_PLUGIN_KEY]: Object.freeze({}),
+  schemaRev: CONFIG_SCHEMA_REV
+});
+
+function isExtension(value) {
+  return _lodash.default.isPlainObject(value) && _lodash.default.isPlainObject(value.appium) && _lodash.default.isString(value.name) && _lodash.default.isString(value.version);
+}
+
+function isDriver(value) {
+  return isExtension(value) && _lodash.default.isString(_lodash.default.get(value, 'appium.driverName')) && _lodash.default.isString(_lodash.default.get(value, 'appium.automationName')) && _lodash.default.isArray(_lodash.default.get(value, 'appium.platformNames'));
+}
+
+function isPlugin(value) {
+  return isExtension(value) && _lodash.default.isString(_lodash.default.get(value, 'appium.pluginName'));
+}
+
+class Manifest {
+  _data;
+  _appiumHome;
+  _manifestPath;
+  _writing;
+  _reading;
+
+  constructor(appiumHome) {
+    this._appiumHome = appiumHome;
+    this._data = _lodash.default.cloneDeep(INITIAL_MANIFEST_DATA);
+  }
+
+  static getInstance = _lodash.default.memoize(function _getInstance(appiumHome) {
+    return new Manifest(appiumHome);
+  });
+
+  async syncWithInstalledExtensions({
+    depthLimit = DEFAULT_SEARCH_DEPTH
+  } = {}) {
+    const walkOpts = _lodash.default.defaults({
+      depthLimit
+    }, DEFAULT_FIND_EXTENSIONS_OPTS);
+
+    let didChange = false;
+
+    for await (const {
+      stats,
+      path: filepath
+    } of _support.fs.walk(this._appiumHome, walkOpts)) {
+      if (filepath !== this._appiumHome && stats.isDirectory()) {
+        try {
+          const pkg = await _support.env.readPackageInDir(filepath);
+
+          if (pkg && isExtension(pkg)) {
+            const added = this.addExtensionFromPackage(pkg, _path.default.join(filepath, 'package.json'));
+            didChange = didChange || added;
+          }
+        } catch {}
+      }
+    }
+
+    return didChange;
+  }
+
+  hasDriver(name) {
+    return Boolean(this._data.drivers[name]);
+  }
+
+  hasPlugin(name) {
+    return Boolean(this._data.plugins[name]);
+  }
+
+  addExtensionFromPackage(pkgJson, pkgPath) {
+    var _pkgJson$peerDependen;
+
+    const extensionPath = _path.default.dirname(pkgPath);
+
+    const internal = {
+      pkgName: pkgJson.name,
+      version: pkgJson.version,
+      appiumVersion: (_pkgJson$peerDependen = pkgJson.peerDependencies) === null || _pkgJson$peerDependen === void 0 ? void 0 : _pkgJson$peerDependen.appium,
+      installType: _extensionConfig.INSTALL_TYPE_NPM,
+      installSpec: `${pkgJson.name}@${pkgJson.version}`
+    };
+
+    if (isDriver(pkgJson)) {
+      if (!this.hasDriver(pkgJson.appium.driverName)) {
+        this.addExtension(_constants.DRIVER_TYPE, pkgJson.appium.driverName, { ..._lodash.default.omit(pkgJson.appium, 'driverName'),
+          ...internal
+        });
+        return true;
+      }
+
+      return false;
+    } else if (isPlugin(pkgJson)) {
+      if (!this.hasPlugin(pkgJson.appium.pluginName)) {
+        this.addExtension(_constants.PLUGIN_TYPE, pkgJson.appium.pluginName, { ..._lodash.default.omit(pkgJson.appium, 'pluginName'),
+          ...internal
+        });
+        return true;
+      }
+
+      return false;
+    } else {
+      throw new TypeError(`The extension in ${extensionPath} is neither a valid driver nor a valid plugin.`);
+    }
+  }
+
+  addExtension(extType, extName, extData) {
+    const data = _lodash.default.clone(extData);
+
+    this._data[`${extType}s`][extName] = data;
+    return data;
+  }
+
+  get appiumHome() {
+    return this._appiumHome;
+  }
+
+  get manifestPath() {
+    return this._manifestPath;
+  }
+
+  getExtensionData(extType) {
+    return this._data[`${extType}s`];
+  }
+
+  async read() {
+    if (this._reading) {
+      await this._reading;
+      return this._data;
+    }
+
+    this._reading = (async () => {
+      let data;
+      let isNewFile = false;
+      await this._setManifestPath();
+
+      try {
+        _logger.default.debug(`Reading ${this._manifestPath}...`);
+
+        const yaml = await _support.fs.readFile(this._manifestPath, 'utf8');
+        data = _yaml.default.parse(yaml);
+
+        _logger.default.debug(`Parsed manifest file: ${JSON.stringify(data, null, 2)}`);
+      } catch (err) {
+        if (err.code === 'ENOENT') {
+          data = _lodash.default.cloneDeep(INITIAL_MANIFEST_DATA);
+          isNewFile = true;
+        } else {
+          if (this._manifestPath) {
+            throw new Error(`Appium had trouble loading the extension installation ` + `cache file (${this._manifestPath}). It may be invalid YAML. Specific error: ${err.message}`);
+          } else {
+            throw new Error(`Appium encountered an unknown problem. Specific error: ${err.message}`);
+          }
+        }
+      }
+
+      this._data = data;
+      let installedExtensionsChanged = false;
+
+      if ((await _support.env.hasAppiumDependency(this.appiumHome)) && (await (0, _packageChanged.packageDidChange)(this.appiumHome))) {
+        installedExtensionsChanged = await this.syncWithInstalledExtensions();
+      }
+
+      if (isNewFile || installedExtensionsChanged) {
+        await this.write();
+      }
+    })();
+
+    try {
+      await this._reading;
+      return this._data;
+    } finally {
+      this._reading = undefined;
+    }
+  }
+
+  async _setManifestPath() {
+    if (!this._manifestPath) {
+      this._manifestPath = await _support.env.resolveManifestPath(this._appiumHome);
+
+      if (_path.default.relative(this._appiumHome, this._manifestPath).startsWith('.')) {
+        throw new Error(`Mismatch between location of APPIUM_HOME and manifest file. APPIUM_HOME: ${this.appiumHome}, manifest file: ${this._manifestPath}`);
+      }
+    }
+
+    return this._manifestPath;
+  }
+
+  async write() {
+    if (this._writing) {
+      return this._writing;
+    }
+
+    this._writing = (async () => {
+      await this._setManifestPath();
+
+      try {
+        await _support.fs.mkdirp(_path.default.dirname(this._manifestPath));
+      } catch (err) {
+        throw new Error(`Appium could not create the directory for the manifest file: ${_path.default.dirname(this._manifestPath)}. Original error: ${err.message}`);
+      }
+
+      try {
+        await _support.fs.writeFile(this._manifestPath, _yaml.default.stringify(this._data), 'utf8');
+        return true;
+      } catch (err) {
+        throw new Error(`Appium could not write to manifest at ${this._manifestPath} using APPIUM_HOME ${this._appiumHome}. ` + `Please ensure it is writable. Original error: ${err.message}`);
+      }
+    })();
+
+    try {
+      return await this._writing;
+    } finally {
+      this._writing = undefined;
+    }
+  }
+
+}
+
+exports.Manifest = Manifest;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DEFAULT_SEARCH_DEPTH","DEFAULT_FIND_EXTENSIONS_OPTS","Object","freeze","depthLimit","filter","filepath","path","basename","startsWith","CONFIG_SCHEMA_REV","CONFIG_DATA_DRIVER_KEY","DRIVER_TYPE","CONFIG_DATA_PLUGIN_KEY","PLUGIN_TYPE","INITIAL_MANIFEST_DATA","schemaRev","isExtension","value","_","isPlainObject","appium","isString","name","version","isDriver","get","isArray","isPlugin","Manifest","_data","_appiumHome","_manifestPath","_writing","_reading","constructor","appiumHome","cloneDeep","getInstance","memoize","_getInstance","syncWithInstalledExtensions","walkOpts","defaults","didChange","stats","fs","walk","isDirectory","pkg","env","readPackageInDir","added","addExtensionFromPackage","join","hasDriver","Boolean","drivers","hasPlugin","plugins","pkgJson","pkgPath","extensionPath","dirname","internal","pkgName","appiumVersion","peerDependencies","installType","INSTALL_TYPE_NPM","installSpec","driverName","addExtension","omit","pluginName","TypeError","extType","extName","extData","data","clone","manifestPath","getExtensionData","read","isNewFile","_setManifestPath","log","debug","yaml","readFile","YAML","parse","JSON","stringify","err","code","Error","message","installedExtensionsChanged","hasAppiumDependency","packageDidChange","write","undefined","resolveManifestPath","relative","mkdirp","writeFile"],"sources":["../../../lib/extension/manifest.js"],"sourcesContent":["/**\n * Module containing {@link Manifest} which handles reading & writing of extension config files.\n */\n\nimport {env, fs} from '@appium/support';\nimport _ from 'lodash';\nimport path from 'path';\nimport YAML from 'yaml';\nimport {DRIVER_TYPE, PLUGIN_TYPE} from '../constants';\nimport log from '../logger';\nimport {INSTALL_TYPE_NPM} from './extension-config';\nimport {packageDidChange} from './package-changed';\n\n/**\n * Default depth to search in directory tree for whatever it is we're looking for.\n *\n * It's 4 because smaller numbers didn't work.\n */\nconst DEFAULT_SEARCH_DEPTH = 4;\n\n/**\n * Default options for {@link findExtensions}.\n * @type {Readonly<import('klaw').Options>}\n */\nconst DEFAULT_FIND_EXTENSIONS_OPTS = Object.freeze({\n  depthLimit: DEFAULT_SEARCH_DEPTH,\n  /* istanbul ignore next */\n  filter: (filepath) => !path.basename(filepath).startsWith('.'),\n});\n\n/**\n * Current configuration schema revision!\n */\nconst CONFIG_SCHEMA_REV = 2;\n\n/**\n * The name of the prop (`drivers`) used in `extensions.yaml` for drivers.\n * @type {`${typeof DRIVER_TYPE}s`}\n */\nconst CONFIG_DATA_DRIVER_KEY = `${DRIVER_TYPE}s`;\n\n/**\n * The name of the prop (`plugins`) used in `extensions.yaml` for plugins.\n * @type {`${typeof PLUGIN_TYPE}s`}\n */\nconst CONFIG_DATA_PLUGIN_KEY = `${PLUGIN_TYPE}s`;\n\n/**\n * @type {Readonly<ManifestData>}\n */\nconst INITIAL_MANIFEST_DATA = Object.freeze({\n  [CONFIG_DATA_DRIVER_KEY]: Object.freeze({}),\n  [CONFIG_DATA_PLUGIN_KEY]: Object.freeze({}),\n  schemaRev: CONFIG_SCHEMA_REV,\n});\n\n/**\n * Given a `package.json` return `true` if it represents an Appium Extension (either a driver or plugin).\n *\n * The `package.json` must have an `appium` property which is an object.\n * @param {any} value\n * @returns {value is ExtPackageJson<ExtensionType>}\n */\nfunction isExtension(value) {\n  return (\n    _.isPlainObject(value) &&\n    _.isPlainObject(value.appium) &&\n    _.isString(value.name) &&\n    _.isString(value.version)\n  );\n}\n/**\n * Given a `package.json`, return `true` if it represents an Appium Driver.\n *\n * To be considered a driver, a `package.json` must have a fields\n * `appium.driverName`, `appium.automationName` and `appium.platformNames`.\n * @param {any} value - Value to test\n * @returns {value is ExtPackageJson<DriverType>}\n */\nfunction isDriver(value) {\n  return (\n    isExtension(value) &&\n    _.isString(_.get(value, 'appium.driverName')) &&\n    _.isString(_.get(value, 'appium.automationName')) &&\n    _.isArray(_.get(value, 'appium.platformNames'))\n  );\n}\n\n/**\n * Given a `package.json`, return `true` if it represents an Appium Plugin.\n *\n * To be considered a plugin, a `package.json` must have an `appium.pluginName` field.\n * @param {any} value - Value to test\n * @returns {value is ExtPackageJson<PluginType>}\n */\nfunction isPlugin(value) {\n  return isExtension(value) && _.isString(_.get(value, 'appium.pluginName'));\n}\n\n/**\n * Handles reading & writing of extension config files.\n *\n * Only one instance of this class exists per value of `APPIUM_HOME`.\n */\nexport class Manifest {\n  /**\n   * The entire contents of a parsed YAML extension config file.\n   *\n   * Contains proxies for automatic persistence on disk\n   * @type {ManifestData}\n   * @private\n   */\n  _data;\n\n  /**\n   * Path to `APPIUM_HOME`.\n   * @private\n   * @type {Readonly<string>}\n   */\n  _appiumHome;\n\n  /**\n   * Path to `extensions.yaml`\n   * @type {string}\n   * Not set until {@link Manifest.read} is called.\n   */\n  _manifestPath;\n\n  /**\n   * Helps avoid writing multiple times.\n   *\n   * If this is `undefined`, calling {@link Manifest.write} will cause it to be\n   * set to a `Promise`. When the call to `write()` is complete, the `Promise`\n   * will resolve and then this value will be set to `undefined`.  Concurrent calls\n   * made while this value is a `Promise` will return the `Promise` itself.\n   * @private\n   * @type {Promise<boolean>|undefined}\n   */\n  _writing;\n\n  /**\n   * Helps avoid reading multiple times.\n   *\n   * If this is `undefined`, calling {@link Manifest.read} will cause it to be\n   * set to a `Promise`. When the call to `read()` is complete, the `Promise`\n   * will resolve and then this value will be set to `undefined`.  Concurrent calls\n   * made while this value is a `Promise` will return the `Promise` itself.\n   * @private\n   * @type {Promise<void>|undefined}\n   */\n  _reading;\n\n  /**\n   * Sets internal data to a fresh clone of {@link INITIAL_MANIFEST_DATA}\n   *\n   * Use {@link Manifest.getInstance} instead.\n   * @param {string} appiumHome\n   * @private\n   */\n  constructor(appiumHome) {\n    this._appiumHome = appiumHome;\n    this._data = _.cloneDeep(INITIAL_MANIFEST_DATA);\n  }\n\n  /**\n   * Returns a new or existing {@link Manifest} instance, based on the value of `appiumHome`.\n   *\n   * Maintains one instance per value of `appiumHome`.\n   * @param {string} appiumHome - Path to `APPIUM_HOME`\n   * @returns {Manifest}\n   */\n  static getInstance = _.memoize(function _getInstance(appiumHome) {\n    return new Manifest(appiumHome);\n  });\n\n  /**\n   * Searches `APPIUM_HOME` for installed extensions and adds them to the manifest.\n   * @param {SyncWithInstalledExtensionsOpts} opts\n   * @returns {Promise<boolean>} `true` if any extensions were added, `false` otherwise.\n   */\n  async syncWithInstalledExtensions({depthLimit = DEFAULT_SEARCH_DEPTH} = {}) {\n    const walkOpts = _.defaults({depthLimit}, DEFAULT_FIND_EXTENSIONS_OPTS);\n    // this could be parallelized, but we can't use fs.walk as an async iterator\n    let didChange = false;\n    for await (const {stats, path: filepath} of fs.walk(this._appiumHome, walkOpts)) {\n      if (filepath !== this._appiumHome && stats.isDirectory()) {\n        try {\n          const pkg = await env.readPackageInDir(filepath);\n          if (pkg && isExtension(pkg)) {\n            // it's possible that this extension already exists in the manifest,\n            // so only update `didChange` if it's new.\n            const added = this.addExtensionFromPackage(pkg, path.join(filepath, 'package.json'));\n            didChange = didChange || added;\n          }\n        } catch {}\n      }\n    }\n    return didChange;\n  }\n\n  /**\n   * Returns `true` if driver with name `name` is registered.\n   * @param {string} name - Driver name\n   * @returns {boolean}\n   */\n  hasDriver(name) {\n    return Boolean(this._data.drivers[name]);\n  }\n\n  /**\n   * Returns `true` if plugin with name `name` is registered.\n   * @param {string} name - Plugin name\n   * @returns {boolean}\n   */\n  hasPlugin(name) {\n    return Boolean(this._data.plugins[name]);\n  }\n\n  /**\n   * Given a path to a `package.json`, add it as either a driver or plugin to the manifest.\n   *\n   * Will _not_ overwrite existing entries.\n   * @template {ExtensionType} ExtType\n   * @param {ExtPackageJson<ExtType>} pkgJson\n   * @param {string} pkgPath\n   * @returns {boolean} - `true` upon success, `false` if the extension is already registered.\n   */\n  addExtensionFromPackage(pkgJson, pkgPath) {\n    const extensionPath = path.dirname(pkgPath);\n\n    /**\n     * @type {InternalMetadata}\n     */\n    const internal = {\n      pkgName: pkgJson.name,\n      version: pkgJson.version,\n      appiumVersion: pkgJson.peerDependencies?.appium,\n      installType: INSTALL_TYPE_NPM,\n      installSpec: `${pkgJson.name}@${pkgJson.version}`,\n    };\n\n    if (isDriver(pkgJson)) {\n      if (!this.hasDriver(pkgJson.appium.driverName)) {\n        this.addExtension(DRIVER_TYPE, pkgJson.appium.driverName, {\n          ..._.omit(pkgJson.appium, 'driverName'),\n          ...internal,\n        });\n        return true;\n      }\n      return false;\n    } else if (isPlugin(pkgJson)) {\n      if (!this.hasPlugin(pkgJson.appium.pluginName)) {\n        this.addExtension(PLUGIN_TYPE, pkgJson.appium.pluginName, {\n          ..._.omit(pkgJson.appium, 'pluginName'),\n          ...internal,\n        });\n        return true;\n      }\n      return false;\n    } else {\n      throw new TypeError(\n        `The extension in ${extensionPath} is neither a valid driver nor a valid plugin.`\n      );\n    }\n  }\n\n  /**\n   * Adds an extension to the manifest as was installed by the `appium` CLI.  The\n   * `extData`, `extType`, and `extName` have already been determined.\n   *\n   * See {@link Manifest.addExtensionFromPackage} for adding an extension from an on-disk package.\n   * @template {ExtensionType} ExtType\n   * @param {ExtType} extType - `driver` or `plugin`\n   * @param {string} extName - Name of extension\n   * @param {ExtManifest<ExtType>} extData - Extension metadata\n   * @returns {ExtManifest<ExtType>} A clone of `extData`, potentially with a mutated `appiumVersion` field\n   */\n  addExtension(extType, extName, extData) {\n    const data = _.clone(extData);\n    this._data[`${extType}s`][extName] = data;\n    return data;\n  }\n\n  /**\n   * Returns the APPIUM_HOME path\n   */\n  get appiumHome() {\n    return this._appiumHome;\n  }\n\n  /**\n   * Returns the path to the manifest file\n   */\n  get manifestPath() {\n    return this._manifestPath;\n  }\n\n  /**\n   * Returns extension data for a particular type.\n   *\n   * @template {ExtensionType} ExtType\n   * @param {ExtType} extType\n   * @returns {ExtRecord<ExtType>}\n   */\n  getExtensionData(extType) {\n    return this._data[/** @type {string} */ (`${extType}s`)];\n  }\n\n  /**\n   * Reads manifest from disk and _overwrites_ the internal data.\n   *\n   * If the manifest does not exist on disk, an {@link INITIAL_MANIFEST_DATA \"empty\"} manifest file will be created.\n   *\n   * If `APPIUM_HOME` contains a `package.json` with an `appium` dependency, then a hash of the `package.json` will be taken. If this hash differs from the last hash, the contents of `APPIUM_HOME/node_modules` will be scanned for extensions that may have been installed outside of the `appium` CLI.  Any found extensions will be added to the manifest file, and if so, the manifest file will be written to disk.\n   *\n   * Only one read operation should happen at a time.  This is controlled via the {@link Manifest._reading} property.\n   * @returns {Promise<ManifestData>} The data\n   */\n  async read() {\n    if (this._reading) {\n      await this._reading;\n      return this._data;\n    }\n\n    this._reading = (async () => {\n      /** @type {ManifestData} */\n      let data;\n      let isNewFile = false;\n      await this._setManifestPath();\n      try {\n        log.debug(`Reading ${this._manifestPath}...`);\n        const yaml = await fs.readFile(this._manifestPath, 'utf8');\n        data = YAML.parse(yaml);\n        log.debug(`Parsed manifest file: ${JSON.stringify(data, null, 2)}`);\n      } catch (err) {\n        if (err.code === 'ENOENT') {\n          data = _.cloneDeep(INITIAL_MANIFEST_DATA);\n          isNewFile = true;\n        } else {\n          if (this._manifestPath) {\n            throw new Error(\n              `Appium had trouble loading the extension installation ` +\n                `cache file (${this._manifestPath}). It may be invalid YAML. Specific error: ${err.message}`\n            );\n          } else {\n            throw new Error(\n              `Appium encountered an unknown problem. Specific error: ${err.message}`\n            );\n          }\n        }\n      }\n\n      this._data = data;\n      let installedExtensionsChanged = false;\n      if (\n        (await env.hasAppiumDependency(this.appiumHome)) &&\n        (await packageDidChange(this.appiumHome))\n      ) {\n        installedExtensionsChanged = await this.syncWithInstalledExtensions();\n      }\n\n      if (isNewFile || installedExtensionsChanged) {\n        await this.write();\n      }\n    })();\n    try {\n      await this._reading;\n      return this._data;\n    } finally {\n      this._reading = undefined;\n    }\n  }\n\n  /**\n   * Ensures {@link Manifest._manifestPath} is set.\n   *\n   * Creates the directory if necessary.\n   * @private\n   * @returns {Promise<string>}\n   */\n  async _setManifestPath() {\n    if (!this._manifestPath) {\n      this._manifestPath = await env.resolveManifestPath(this._appiumHome);\n\n      /* istanbul ignore if */\n      if (path.relative(this._appiumHome, this._manifestPath).startsWith('.')) {\n        throw new Error(\n          `Mismatch between location of APPIUM_HOME and manifest file. APPIUM_HOME: ${this.appiumHome}, manifest file: ${this._manifestPath}`\n        );\n      }\n    }\n\n    return this._manifestPath;\n  }\n\n  /**\n   * Writes the data if it need s writing.\n   *\n   * If the `schemaRev` prop needs updating, the file will be written.\n   *\n   * @todo If this becomes too much of a bottleneck, throttle it.\n   * @returns {Promise<boolean>} Whether the data was written\n   */\n  async write() {\n    if (this._writing) {\n      return this._writing;\n    }\n    this._writing = (async () => {\n      await this._setManifestPath();\n      try {\n        await fs.mkdirp(path.dirname(this._manifestPath));\n      } catch (err) {\n        throw new Error(\n          `Appium could not create the directory for the manifest file: ${path.dirname(\n            this._manifestPath\n          )}. Original error: ${err.message}`\n        );\n      }\n      try {\n        await fs.writeFile(this._manifestPath, YAML.stringify(this._data), 'utf8');\n        return true;\n      } catch (err) {\n        throw new Error(\n          `Appium could not write to manifest at ${this._manifestPath} using APPIUM_HOME ${this._appiumHome}. ` +\n            `Please ensure it is writable. Original error: ${err.message}`\n        );\n      }\n    })();\n    try {\n      return await this._writing;\n    } finally {\n      this._writing = undefined;\n    }\n  }\n}\n\n/**\n * Type of the string referring to a driver (typically as a key or type string)\n * @typedef {import('@appium/types').DriverType} DriverType\n */\n\n/**\n * Type of the string referring to a plugin (typically as a key or type string)\n * @typedef {import('@appium/types').PluginType} PluginType\n */\n\n/**\n * @typedef SyncWithInstalledExtensionsOpts\n * @property {number} [depthLimit] - Maximum depth to recurse into subdirectories\n */\n\n/**\n * @typedef {import('appium/types').ManifestData} ManifestData\n * @typedef {import('appium/types').InternalMetadata} InternalMetadata\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtPackageJson<T>} ExtPackageJson\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtRecord<T>} ExtRecord\n */\n\n/**\n * Either `driver` or `plugin` rn\n * @typedef {import('@appium/types').ExtensionType} ExtensionType\n */\n"],"mappings":"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"}

package/build/lib/extension/package-changed.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Determines if extensions have changed, and updates a hash the `package.json` in `appiumHome` if so.
+ *
+ * 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 function packageDidChange(appiumHome: string): Promise<boolean>;
+//# sourceMappingURL=package-changed.d.ts.map

package/build/lib/extension/package-changed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-changed.d.ts","sourceRoot":"","sources":["../../../lib/extension/package-changed.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,6CAHW,MAAM,GACJ,QAAQ,OAAO,CAAC,CAkD5B"}