appium 2.0.0-beta.41 → 2.0.0-beta.44

package/build/lib/cli/plugin-command.js

@@ -61,11 +61,13 @@ class PluginCommand extends _extensionCommand.default {
 
   async run({
     plugin,
-    scriptName
+    scriptName,
+    extraArgs
   }) {
     return await super._run({
       installSpec: plugin,
-      scriptName
+      scriptName,
+      extraArgs
     });
   }
 
@@ -87,4 +89,4 @@ class PluginCommand extends _extensionCommand.default {
 }
 
 exports.default = PluginCommand;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/config-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config-file.d.ts","sourceRoot":"","sources":["../../lib/config-file.js"],"names":[],"mappings":"AAkEA;;;;;;;;;;;;;;GAcG;AACH,sCAPW,OAAO,KAAK,EAAE,WAAW,EAAE,WAC3B,oBAAoB,CAAC,QAAQ,CAAC,GAAC,GAAG,iDAIhC,MAAM,CAUlB;AAED;;;;;;;;GAQG;AACH,yGAFa,QAAQ,oBAAoB,CAAC,CAwCzC;AAED;;;;GAIG;AACH,wCAHW,YAAY,GACV,sBAAsB,CA+BlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAoBY,WAAW,2BAAoB,WAAW,CAAC,CAAC;;;;2BAK5C,OAAO,eAAe,EAAE,YAAY;;;;qCAKpC,OAAO,eAAe,EAAE,sBAAsB;;;;sBAK9C,MAAM"}
+{"version":3,"file":"config-file.d.ts","sourceRoot":"","sources":["../../lib/config-file.js"],"names":[],"mappings":"AAkEA;;;;;;;;;;;;;;GAcG;AACH,sCAPW,OAAO,KAAK,EAAE,WAAW,EAAE,WAC3B,oBAAoB,CAAC,QAAQ,CAAC,GAAC,GAAG,iDAIhC,MAAM,CAUlB;AAED;;;;;;;;GAQG;AACH,yGAFa,QAAQ,oBAAoB,CAAC,CAwCzC;AAED;;;;GAIG;AACH,wCAHW,YAAY,GACV,sBAAsB,CAiClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAoBY,WAAW,2BAAoB,WAAW,CAAC,CAAC;;;;2BAK5C,OAAO,eAAe,EAAE,YAAY;;;;qCAKpC,OAAO,eAAe,EAAE,sBAAsB;;;;sBAK9C,MAAM"}

package/build/lib/config-file.js

@@ -124,13 +124,15 @@ function normalizeConfig(config) {
     });
 
     return _lodash.default.mapValues(mappedObj, (value, property) => {
+      var _schema$properties;
+
       const nextSection = section ? `${section}.${property}` : property;
-      return isSchemaTypeObject(value) ? normalize(config, nextSection) : value;
+      return isSchemaTypeObject((_schema$properties = schema.properties) === null || _schema$properties === void 0 ? void 0 : _schema$properties[property]) ? normalize(config, nextSection) : value;
     });
   };
 
-  const isSchemaTypeObject = schema => Boolean(schema.properties);
+  const isSchemaTypeObject = schema => Boolean((schema === null || schema === void 0 ? void 0 : schema.properties) || (schema === null || schema === void 0 ? void 0 : schema.type) === 'object');
 
   return normalize(config);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["yamlLoader","filepath","content","yaml","parse","rawConfig","Map","jsonLoader","set","JSON","loadConfigFile","lc","load","err","code","message","SyntaxError","searchConfigFile","search","formatErrors","errors","config","opts","length","TypeError","betterAjvErrors","getSchema","schemaId","json","format","readConfigFile","lilconfig","loaders","noExt","packageProp","result","isEmpty","pretty","configResult","validate","_","reason","get","normalizeConfig","delete","schema","normalize","section","obj","isUndefined","mappedObj","mapKeys","__","prop","properties","appiumCliDest","camelCase","mapValues","value","property","nextSection","isSchemaTypeObject","Boolean"],"sources":["../../lib/config-file.js"],"sourcesContent":["import betterAjvErrors from '@sidvind/better-ajv-errors';\nimport {lilconfig} from 'lilconfig';\nimport _ from 'lodash';\nimport yaml from 'yaml';\nimport {getSchema, validate} from './schema/schema';\n\n/**\n * lilconfig loader to handle `.yaml` files\n * @type {import('lilconfig').LoaderSync}\n */\nfunction yamlLoader(filepath, content) {\n  return yaml.parse(content);\n}\n\n/**\n * A cache of the raw config file (a JSON string) at a filepath.\n * This is used for better error reporting.\n * Note that config files needn't be JSON, but it helps if they are.\n * @type {Map<string,RawJson>}\n */\nconst rawConfig = new Map();\n\n/**\n * Custom JSON loader that caches the raw config file (for use with `better-ajv-errors`).\n * If it weren't for this cache, this would be unnecessary.\n * @type {import('lilconfig').LoaderSync}\n */\nfunction jsonLoader(filepath, content) {\n  rawConfig.set(filepath, content);\n  return JSON.parse(content);\n}\n\n/**\n * Loads a config file from an explicit path\n * @param {LilconfigAsyncSearcher} lc - lilconfig instance\n * @param {string} filepath - Path to config file\n * @returns {Promise<import('lilconfig').LilconfigResult>}\n */\nasync function loadConfigFile(lc, filepath) {\n  try {\n    // removing \"await\" will cause any rejection to _not_ be caught in this block!\n    return await lc.load(filepath);\n  } catch (/** @type {unknown} */ err) {\n    if (/** @type {NodeJS.ErrnoException} */ (err).code === 'ENOENT') {\n      /** @type {NodeJS.ErrnoException} */ (\n        err\n      ).message = `Config file not found at user-provided path: ${filepath}`;\n      throw err;\n    } else if (err instanceof SyntaxError) {\n      // generally invalid JSON\n      err.message = `Config file at user-provided path ${filepath} is invalid:\\n${err.message}`;\n      throw err;\n    }\n    throw err;\n  }\n}\n\n/**\n * Searches for a config file\n * @param {LilconfigAsyncSearcher} lc - lilconfig instance\n * @returns {Promise<import('lilconfig').LilconfigResult>}\n */\nasync function searchConfigFile(lc) {\n  return await lc.search();\n}\n\n/**\n * Given an array of errors and the result of loading a config file, generate a\n * helpful string for the user.\n *\n * - If `opts` contains a `json` property, this should be the original JSON\n *   _string_ of the config file.  This is only applicable if the config file\n *   was in JSON format. If present, it will associate line numbers with errors.\n * - If `errors` happens to be empty, this will throw.\n * @param {import('ajv').ErrorObject[]} errors - Non-empty array of errors. Required.\n * @param {ReadConfigFileResult['config']|any} [config] -\n * Configuration & metadata\n * @param {FormatConfigErrorsOptions} [opts]\n * @throws {TypeError} If `errors` is empty\n * @returns {string}\n */\nexport function formatErrors(errors = [], config = {}, opts = {}) {\n  if (errors && !errors.length) {\n    throw new TypeError('Array of errors must be non-empty');\n  }\n  return betterAjvErrors(getSchema(opts.schemaId), config, errors, {\n    json: opts.json,\n    format: 'cli',\n  });\n}\n\n/**\n * Given an optional path, read a config file. Validates the config file.\n *\n * Call {@link validate} if you already have a config object.\n * @param {string} [filepath] - Path to config file, if we have one\n * @param {ReadConfigFileOptions} [opts] - Options\n * @public\n * @returns {Promise<ReadConfigFileResult>} Contains config and filepath, if found, and any errors\n */\nexport async function readConfigFile(filepath, opts = {}) {\n  const lc = lilconfig('appium', {\n    loaders: {\n      '.yaml': yamlLoader,\n      '.yml': yamlLoader,\n      '.json': jsonLoader,\n      noExt: jsonLoader,\n    },\n    packageProp: 'appiumConfig',\n  });\n\n  const result = filepath ? await loadConfigFile(lc, filepath) : await searchConfigFile(lc);\n\n  if (result?.filepath && !result?.isEmpty) {\n    const {pretty = true} = opts;\n    try {\n      let configResult;\n      const errors = validate(result.config);\n      if (_.isEmpty(errors)) {\n        configResult = {...result, errors};\n      } else {\n        const reason = formatErrors(errors, result.config, {\n          json: rawConfig.get(result.filepath),\n          pretty,\n        });\n        configResult = reason ? {...result, errors, reason} : {...result, errors};\n      }\n\n      // normalize (to camel case) all top-level property names of the config file\n      configResult.config = normalizeConfig(/** @type {AppiumConfig} */ (configResult.config));\n\n      return configResult;\n    } finally {\n      // clean up the raw config file cache, which is only kept to better report errors.\n      rawConfig.delete(result.filepath);\n    }\n  }\n  return result ?? {};\n}\n\n/**\n * Convert schema property names to either a) the value of the `appiumCliDest` property, if any; or b) camel-case\n * @param {AppiumConfig} config - Configuration object\n * @returns {NormalizedAppiumConfig} New object with camel-cased keys (or `dest` keys).\n */\nexport function normalizeConfig(config) {\n  const schema = getSchema();\n  /**\n   * @param {AppiumConfig} config\n   * @param {string} [section] - Keypath (lodash `_.get()` style) to section of config. If omitted, assume root Appium config schema\n   * @todo Rewrite as a loop\n   * @returns Normalized section of config\n   */\n  const normalize = (config, section) => {\n    const obj = _.isUndefined(section) ? config : _.get(config, section, config);\n\n    const mappedObj = _.mapKeys(\n      obj,\n      (__, prop) => schema.properties[prop]?.appiumCliDest ?? _.camelCase(prop)\n    );\n\n    return _.mapValues(mappedObj, (value, property) => {\n      const nextSection = section ? `${section}.${property}` : property;\n      return isSchemaTypeObject(value) ? normalize(config, nextSection) : value;\n    });\n  };\n\n  /**\n   * Returns `true` if the schema prop references an object, or if it's an object itself\n   * @param {import('ajv').SchemaObject|object} schema - Referencing schema object\n   */\n  const isSchemaTypeObject = (schema) => Boolean(schema.properties);\n\n  return normalize(config);\n}\n\n/**\n * Result of calling {@link readConfigFile}.\n * @typedef ReadConfigFileResult\n * @property {import('ajv').ErrorObject[]} [errors] - Validation errors\n * @property {string} [filepath] - The path to the config file, if found\n * @property {boolean} [isEmpty] - If `true`, the config file exists but is empty\n * @property {NormalizedAppiumConfig} [config] - The parsed configuration\n * @property {string|import('@sidvind/better-ajv-errors').IOutputError[]} [reason] - Human-readable error messages and suggestions. If the `pretty` option is `true`, this will be a nice string to print.\n */\n\n/**\n * Options for {@link readConfigFile}.\n * @typedef ReadConfigFileOptions\n * @property {boolean} [pretty=true] If `false`, do not use color and fancy formatting in the `reason` property of the {@link ReadConfigFileResult}. The value of `reason` is then suitable for machine-reading.\n */\n\n/**\n * This is an `AsyncSearcher` which is inexplicably _not_ exported by the `lilconfig` type definition.\n * @typedef {ReturnType<import('lilconfig')[\"lilconfig\"]>} LilconfigAsyncSearcher\n */\n\n/**\n * The contents of an Appium config file. Generated from schema\n * @typedef {import('@appium/types').AppiumConfig} AppiumConfig\n */\n\n/**\n * The contents of an Appium config file with camelcased property names (and using `appiumCliDest` value if present). Generated from {@link AppiumConfig}\n * @typedef {import('@appium/types').NormalizedAppiumConfig} NormalizedAppiumConfig\n */\n\n/**\n * The string should be a raw JSON string.\n * @typedef {string} RawJson\n */\n\n/**\n * Options for {@link formatErrors}.\n * @typedef FormatConfigErrorsOptions\n * @property {import('./config-file').RawJson} [json] - Raw JSON config (as string)\n * @property {boolean} [pretty=true] - Whether to format errors as a CLI-friendly string\n * @property {string}  [schemaId] - Specific ID of a prop; otherwise entire schema\n */\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["yamlLoader","filepath","content","yaml","parse","rawConfig","Map","jsonLoader","set","JSON","loadConfigFile","lc","load","err","code","message","SyntaxError","searchConfigFile","search","formatErrors","errors","config","opts","length","TypeError","betterAjvErrors","getSchema","schemaId","json","format","readConfigFile","lilconfig","loaders","noExt","packageProp","result","isEmpty","pretty","configResult","validate","_","reason","get","normalizeConfig","delete","schema","normalize","section","obj","isUndefined","mappedObj","mapKeys","__","prop","properties","appiumCliDest","camelCase","mapValues","value","property","nextSection","isSchemaTypeObject","Boolean","type"],"sources":["../../lib/config-file.js"],"sourcesContent":["import betterAjvErrors from '@sidvind/better-ajv-errors';\nimport {lilconfig} from 'lilconfig';\nimport _ from 'lodash';\nimport yaml from 'yaml';\nimport {getSchema, validate} from './schema/schema';\n\n/**\n * lilconfig loader to handle `.yaml` files\n * @type {import('lilconfig').LoaderSync}\n */\nfunction yamlLoader(filepath, content) {\n  return yaml.parse(content);\n}\n\n/**\n * A cache of the raw config file (a JSON string) at a filepath.\n * This is used for better error reporting.\n * Note that config files needn't be JSON, but it helps if they are.\n * @type {Map<string,RawJson>}\n */\nconst rawConfig = new Map();\n\n/**\n * Custom JSON loader that caches the raw config file (for use with `better-ajv-errors`).\n * If it weren't for this cache, this would be unnecessary.\n * @type {import('lilconfig').LoaderSync}\n */\nfunction jsonLoader(filepath, content) {\n  rawConfig.set(filepath, content);\n  return JSON.parse(content);\n}\n\n/**\n * Loads a config file from an explicit path\n * @param {LilconfigAsyncSearcher} lc - lilconfig instance\n * @param {string} filepath - Path to config file\n * @returns {Promise<import('lilconfig').LilconfigResult>}\n */\nasync function loadConfigFile(lc, filepath) {\n  try {\n    // removing \"await\" will cause any rejection to _not_ be caught in this block!\n    return await lc.load(filepath);\n  } catch (/** @type {unknown} */ err) {\n    if (/** @type {NodeJS.ErrnoException} */ (err).code === 'ENOENT') {\n      /** @type {NodeJS.ErrnoException} */ (\n        err\n      ).message = `Config file not found at user-provided path: ${filepath}`;\n      throw err;\n    } else if (err instanceof SyntaxError) {\n      // generally invalid JSON\n      err.message = `Config file at user-provided path ${filepath} is invalid:\\n${err.message}`;\n      throw err;\n    }\n    throw err;\n  }\n}\n\n/**\n * Searches for a config file\n * @param {LilconfigAsyncSearcher} lc - lilconfig instance\n * @returns {Promise<import('lilconfig').LilconfigResult>}\n */\nasync function searchConfigFile(lc) {\n  return await lc.search();\n}\n\n/**\n * Given an array of errors and the result of loading a config file, generate a\n * helpful string for the user.\n *\n * - If `opts` contains a `json` property, this should be the original JSON\n *   _string_ of the config file.  This is only applicable if the config file\n *   was in JSON format. If present, it will associate line numbers with errors.\n * - If `errors` happens to be empty, this will throw.\n * @param {import('ajv').ErrorObject[]} errors - Non-empty array of errors. Required.\n * @param {ReadConfigFileResult['config']|any} [config] -\n * Configuration & metadata\n * @param {FormatConfigErrorsOptions} [opts]\n * @throws {TypeError} If `errors` is empty\n * @returns {string}\n */\nexport function formatErrors(errors = [], config = {}, opts = {}) {\n  if (errors && !errors.length) {\n    throw new TypeError('Array of errors must be non-empty');\n  }\n  return betterAjvErrors(getSchema(opts.schemaId), config, errors, {\n    json: opts.json,\n    format: 'cli',\n  });\n}\n\n/**\n * Given an optional path, read a config file. Validates the config file.\n *\n * Call {@link validate} if you already have a config object.\n * @param {string} [filepath] - Path to config file, if we have one\n * @param {ReadConfigFileOptions} [opts] - Options\n * @public\n * @returns {Promise<ReadConfigFileResult>} Contains config and filepath, if found, and any errors\n */\nexport async function readConfigFile(filepath, opts = {}) {\n  const lc = lilconfig('appium', {\n    loaders: {\n      '.yaml': yamlLoader,\n      '.yml': yamlLoader,\n      '.json': jsonLoader,\n      noExt: jsonLoader,\n    },\n    packageProp: 'appiumConfig',\n  });\n\n  const result = filepath ? await loadConfigFile(lc, filepath) : await searchConfigFile(lc);\n\n  if (result?.filepath && !result?.isEmpty) {\n    const {pretty = true} = opts;\n    try {\n      let configResult;\n      const errors = validate(result.config);\n      if (_.isEmpty(errors)) {\n        configResult = {...result, errors};\n      } else {\n        const reason = formatErrors(errors, result.config, {\n          json: rawConfig.get(result.filepath),\n          pretty,\n        });\n        configResult = reason ? {...result, errors, reason} : {...result, errors};\n      }\n\n      // normalize (to camel case) all top-level property names of the config file\n      configResult.config = normalizeConfig(/** @type {AppiumConfig} */ (configResult.config));\n\n      return configResult;\n    } finally {\n      // clean up the raw config file cache, which is only kept to better report errors.\n      rawConfig.delete(result.filepath);\n    }\n  }\n  return result ?? {};\n}\n\n/**\n * Convert schema property names to either a) the value of the `appiumCliDest` property, if any; or b) camel-case\n * @param {AppiumConfig} config - Configuration object\n * @returns {NormalizedAppiumConfig} New object with camel-cased keys (or `dest` keys).\n */\nexport function normalizeConfig(config) {\n  const schema = getSchema();\n  /**\n   * @param {AppiumConfig} config\n   * @param {string} [section] - Keypath (lodash `_.get()` style) to section of config. If omitted, assume root Appium config schema\n   * @todo Rewrite as a loop\n   * @returns Normalized section of config\n   */\n  const normalize = (config, section) => {\n    const obj = _.isUndefined(section) ? config : _.get(config, section, config);\n\n    const mappedObj = _.mapKeys(\n      obj,\n      (__, prop) => schema.properties[prop]?.appiumCliDest ?? _.camelCase(prop)\n    );\n\n    return _.mapValues(mappedObj, (value, property) => {\n      const nextSection = section ? `${section}.${property}` : property;\n      return isSchemaTypeObject(schema.properties?.[property])\n        ? normalize(config, nextSection)\n        : value;\n    });\n  };\n\n  /**\n   * Returns `true` if the schema prop references an object, or if it's an object itself\n   * @param {import('ajv').SchemaObject|object} schema - Referencing schema object\n   */\n  const isSchemaTypeObject = (schema) => Boolean(schema?.properties || schema?.type === 'object');\n\n  return normalize(config);\n}\n\n/**\n * Result of calling {@link readConfigFile}.\n * @typedef ReadConfigFileResult\n * @property {import('ajv').ErrorObject[]} [errors] - Validation errors\n * @property {string} [filepath] - The path to the config file, if found\n * @property {boolean} [isEmpty] - If `true`, the config file exists but is empty\n * @property {NormalizedAppiumConfig} [config] - The parsed configuration\n * @property {string|import('@sidvind/better-ajv-errors').IOutputError[]} [reason] - Human-readable error messages and suggestions. If the `pretty` option is `true`, this will be a nice string to print.\n */\n\n/**\n * Options for {@link readConfigFile}.\n * @typedef ReadConfigFileOptions\n * @property {boolean} [pretty=true] If `false`, do not use color and fancy formatting in the `reason` property of the {@link ReadConfigFileResult}. The value of `reason` is then suitable for machine-reading.\n */\n\n/**\n * This is an `AsyncSearcher` which is inexplicably _not_ exported by the `lilconfig` type definition.\n * @typedef {ReturnType<import('lilconfig')[\"lilconfig\"]>} LilconfigAsyncSearcher\n */\n\n/**\n * The contents of an Appium config file. Generated from schema\n * @typedef {import('@appium/types').AppiumConfig} AppiumConfig\n */\n\n/**\n * The contents of an Appium config file with camelcased property names (and using `appiumCliDest` value if present). Generated from {@link AppiumConfig}\n * @typedef {import('@appium/types').NormalizedAppiumConfig} NormalizedAppiumConfig\n */\n\n/**\n * The string should be a raw JSON string.\n * @typedef {string} RawJson\n */\n\n/**\n * Options for {@link formatErrors}.\n * @typedef FormatConfigErrorsOptions\n * @property {import('./config-file').RawJson} [json] - Raw JSON config (as string)\n * @property {boolean} [pretty=true] - Whether to format errors as a CLI-friendly string\n * @property {string}  [schemaId] - Specific ID of a prop; otherwise entire schema\n */\n"],"mappings":";;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AAMA,SAASA,UAAT,CAAoBC,QAApB,EAA8BC,OAA9B,EAAuC;EACrC,OAAOC,aAAA,CAAKC,KAAL,CAAWF,OAAX,CAAP;AACD;;AAQD,MAAMG,SAAS,GAAG,IAAIC,GAAJ,EAAlB;;AAOA,SAASC,UAAT,CAAoBN,QAApB,EAA8BC,OAA9B,EAAuC;EACrCG,SAAS,CAACG,GAAV,CAAcP,QAAd,EAAwBC,OAAxB;EACA,OAAOO,IAAI,CAACL,KAAL,CAAWF,OAAX,CAAP;AACD;;AAQD,eAAeQ,cAAf,CAA8BC,EAA9B,EAAkCV,QAAlC,EAA4C;EAC1C,IAAI;IAEF,OAAO,MAAMU,EAAE,CAACC,IAAH,CAAQX,QAAR,CAAb;EACD,CAHD,CAGE,OAA8BY,GAA9B,EAAmC;IACnC,IAA0CA,GAAD,CAAMC,IAAN,KAAe,QAAxD,EAAkE;MAE9DD,GADmC,CAEnCE,OAFmC,GAExB,gDAA+Cd,QAAS,EAFhC;MAGrC,MAAMY,GAAN;IACD,CALD,MAKO,IAAIA,GAAG,YAAYG,WAAnB,EAAgC;MAErCH,GAAG,CAACE,OAAJ,GAAe,qCAAoCd,QAAS,iBAAgBY,GAAG,CAACE,OAAQ,EAAxF;MACA,MAAMF,GAAN;IACD;;IACD,MAAMA,GAAN;EACD;AACF;;AAOD,eAAeI,gBAAf,CAAgCN,EAAhC,EAAoC;EAClC,OAAO,MAAMA,EAAE,CAACO,MAAH,EAAb;AACD;;AAiBM,SAASC,YAAT,CAAsBC,MAAM,GAAG,EAA/B,EAAmCC,MAAM,GAAG,EAA5C,EAAgDC,IAAI,GAAG,EAAvD,EAA2D;EAChE,IAAIF,MAAM,IAAI,CAACA,MAAM,CAACG,MAAtB,EAA8B;IAC5B,MAAM,IAAIC,SAAJ,CAAc,mCAAd,CAAN;EACD;;EACD,OAAO,IAAAC,wBAAA,EAAgB,IAAAC,iBAAA,EAAUJ,IAAI,CAACK,QAAf,CAAhB,EAA0CN,MAA1C,EAAkDD,MAAlD,EAA0D;IAC/DQ,IAAI,EAAEN,IAAI,CAACM,IADoD;IAE/DC,MAAM,EAAE;EAFuD,CAA1D,CAAP;AAID;;AAWM,eAAeC,cAAf,CAA8B7B,QAA9B,EAAwCqB,IAAI,GAAG,EAA/C,EAAmD;EACxD,MAAMX,EAAE,GAAG,IAAAoB,oBAAA,EAAU,QAAV,EAAoB;IAC7BC,OAAO,EAAE;MACP,SAAShC,UADF;MAEP,QAAQA,UAFD;MAGP,SAASO,UAHF;MAIP0B,KAAK,EAAE1B;IAJA,CADoB;IAO7B2B,WAAW,EAAE;EAPgB,CAApB,CAAX;EAUA,MAAMC,MAAM,GAAGlC,QAAQ,GAAG,MAAMS,cAAc,CAACC,EAAD,EAAKV,QAAL,CAAvB,GAAwC,MAAMgB,gBAAgB,CAACN,EAAD,CAArF;;EAEA,IAAIwB,MAAM,SAAN,IAAAA,MAAM,WAAN,IAAAA,MAAM,CAAElC,QAAR,IAAoB,EAACkC,MAAD,aAACA,MAAD,eAACA,MAAM,CAAEC,OAAT,CAAxB,EAA0C;IACxC,MAAM;MAACC,MAAM,GAAG;IAAV,IAAkBf,IAAxB;;IACA,IAAI;MACF,IAAIgB,YAAJ;MACA,MAAMlB,MAAM,GAAG,IAAAmB,gBAAA,EAASJ,MAAM,CAACd,MAAhB,CAAf;;MACA,IAAImB,eAAA,CAAEJ,OAAF,CAAUhB,MAAV,CAAJ,EAAuB;QACrBkB,YAAY,GAAG,EAAC,GAAGH,MAAJ;UAAYf;QAAZ,CAAf;MACD,CAFD,MAEO;QACL,MAAMqB,MAAM,GAAGtB,YAAY,CAACC,MAAD,EAASe,MAAM,CAACd,MAAhB,EAAwB;UACjDO,IAAI,EAAEvB,SAAS,CAACqC,GAAV,CAAcP,MAAM,CAAClC,QAArB,CAD2C;UAEjDoC;QAFiD,CAAxB,CAA3B;QAIAC,YAAY,GAAGG,MAAM,GAAG,EAAC,GAAGN,MAAJ;UAAYf,MAAZ;UAAoBqB;QAApB,CAAH,GAAiC,EAAC,GAAGN,MAAJ;UAAYf;QAAZ,CAAtD;MACD;;MAGDkB,YAAY,CAACjB,MAAb,GAAsBsB,eAAe,CAA8BL,YAAY,CAACjB,MAA3C,CAArC;MAEA,OAAOiB,YAAP;IACD,CAjBD,SAiBU;MAERjC,SAAS,CAACuC,MAAV,CAAiBT,MAAM,CAAClC,QAAxB;IACD;EACF;;EACD,OAAOkC,MAAM,IAAI,EAAjB;AACD;;AAOM,SAASQ,eAAT,CAAyBtB,MAAzB,EAAiC;EACtC,MAAMwB,MAAM,GAAG,IAAAnB,iBAAA,GAAf;;EAOA,MAAMoB,SAAS,GAAG,CAACzB,MAAD,EAAS0B,OAAT,KAAqB;IACrC,MAAMC,GAAG,GAAGR,eAAA,CAAES,WAAF,CAAcF,OAAd,IAAyB1B,MAAzB,GAAkCmB,eAAA,CAAEE,GAAF,CAAMrB,MAAN,EAAc0B,OAAd,EAAuB1B,MAAvB,CAA9C;;IAEA,MAAM6B,SAAS,GAAGV,eAAA,CAAEW,OAAF,CAChBH,GADgB,EAEhB,CAACI,EAAD,EAAKC,IAAL;MAAA;;MAAA,OAAc,0BAAAR,MAAM,CAACS,UAAP,CAAkBD,IAAlB,iFAAyBE,aAAzB,KAA0Cf,eAAA,CAAEgB,SAAF,CAAYH,IAAZ,CAAxD;IAAA,CAFgB,CAAlB;;IAKA,OAAOb,eAAA,CAAEiB,SAAF,CAAYP,SAAZ,EAAuB,CAACQ,KAAD,EAAQC,QAAR,KAAqB;MAAA;;MACjD,MAAMC,WAAW,GAAGb,OAAO,GAAI,GAAEA,OAAQ,IAAGY,QAAS,EAA1B,GAA8BA,QAAzD;MACA,OAAOE,kBAAkB,uBAAChB,MAAM,CAACS,UAAR,uDAAC,mBAAoBK,QAApB,CAAD,CAAlB,GACHb,SAAS,CAACzB,MAAD,EAASuC,WAAT,CADN,GAEHF,KAFJ;IAGD,CALM,CAAP;EAMD,CAdD;;EAoBA,MAAMG,kBAAkB,GAAIhB,MAAD,IAAYiB,OAAO,CAAC,CAAAjB,MAAM,SAAN,IAAAA,MAAM,WAAN,YAAAA,MAAM,CAAES,UAAR,KAAsB,CAAAT,MAAM,SAAN,IAAAA,MAAM,WAAN,YAAAA,MAAM,CAAEkB,IAAR,MAAiB,QAAxC,CAA9C;;EAEA,OAAOjB,SAAS,CAACzB,MAAD,CAAhB;AACD"}

package/build/lib/config.d.ts

@@ -1,3 +1,4 @@
+export function checkNpmOk(): Promise<void>;
 export type ParsedArgs = import('appium/types').ParsedArgs;
 export type Args = import('appium/types').Args;
 export type ArgSpec = import("./schema/arg-spec").ArgSpec<any>;

package/build/lib/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../lib/config.js"],"names":[],"mappings":"yBAiUa,OAAO,cAAc,EAAE,UAAU;mBACjC,OAAO,cAAc,EAAE,IAAI;;AAzMxC;;;;;;GAMG;AACH,gCAFa,OAAO,cAAc,EAAE,SAAS,CAI5C;AAED,oCAKC;AAeD,+CAGC;AAhBD,6CAWC;AA4ID;;GAEG;AACH,uCAFW,MAAM,iBAWhB;AAjJD;;;;GAIG;AACH,oDAHW,IAAI,GACF,IAAI,CAmFhB;AA3LD;;;GAGG;AACH,uEAFa,QAAQ,MAAM,QAAE,CA6B5B;AA3ED,6BAAsC;AAkBtC;;GAEG;AACH,2FAUC;AAwND;;;;;;;;;;GAUG;AACH,0DALW,QAAQ,UAAU,CAAC,gBACnB,OAAO,eAAe,EAAE,oBAAoB,YAC5C,QAAQ,UAAU,CAAC,cACnB,UAAU,QAoBpB;AAgBD,6BAAuC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../lib/config.js"],"names":[],"mappings":"AAsJA,4CAOC;yBAwLY,OAAO,cAAc,EAAE,UAAU;mBACjC,OAAO,cAAc,EAAE,IAAI;;AApNxC;;;;;;GAMG;AACH,gCAFa,OAAO,cAAc,EAAE,SAAS,CAI5C;AAED,oCAOC;AAwBD,+CAGC;AAhBD,6CAWC;AA4ID;;GAEG;AACH,uCAFW,MAAM,iBAWhB;AAjJD;;;;GAIG;AACH,oDAHW,IAAI,GACF,IAAI,CAmFhB;AAtMD;;;GAGG;AACH,uEAFa,QAAQ,MAAM,QAAE,CA6B5B;AArFD,6BAAsC;AA4BtC;;GAEG;AACH,2FAUC;AAmOD;;;;;;;;;;GAUG;AACH,0DALW,QAAQ,UAAU,CAAC,gBACnB,OAAO,eAAe,EAAE,oBAAoB,YAC5C,QAAQ,UAAU,CAAC,cACnB,UAAU,QAoBpB;AAgBD,6BAAuC"}

package/build/lib/config.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.APPIUM_VER = void 0;
 exports.checkNodeOk = checkNodeOk;
+exports.checkNpmOk = checkNpmOk;
 exports.getBuildInfo = getBuildInfo;
 exports.getGitRev = getGitRev;
 exports.getNonDefaultServerArgs = getNonDefaultServerArgs;
@@ -27,8 +28,6 @@ var _axios = _interopRequireDefault(require("axios"));
 
 var _teen_process = require("teen_process");
 
-var _logger = _interopRequireDefault(require("./logger"));
-
 var _semver = _interopRequireDefault(require("semver"));
 
 var _findUp = _interopRequireDefault(require("find-up"));
@@ -40,6 +39,7 @@ const npmPackage = _support.fs.readPackageJsonFrom(__dirname);
 const APPIUM_VER = npmPackage.version;
 exports.APPIUM_VER = APPIUM_VER;
 const MIN_NODE_VERSION = npmPackage.engines.node;
+const MIN_NPM_VERSION = npmPackage.engines.npm;
 const GIT_META_ROOT = '.git';
 const GIT_BINARY = `git${_support.system.isWindows() ? '.exe' : ''}`;
 const GITHUB_API = 'https://api.github.com/repos/appium/appium';
@@ -51,6 +51,13 @@ function getNodeVersion() {
   return _semver.default.coerce(process.version);
 }
 
+async function getNpmVersion() {
+  const {
+    stdout
+  } = await (0, _teen_process.exec)(_support.system.isWindows() ? 'npm.cmd' : 'npm', ['--version']);
+  return stdout.trim();
+}
+
 async function updateBuildInfo(useGithubApiFallback = false) {
   const sha = await getGitRev(useGithubApiFallback);
 
@@ -143,7 +150,15 @@ function checkNodeOk() {
   const version = getNodeVersion();
 
   if (!_semver.default.satisfies(version, MIN_NODE_VERSION)) {
-    _logger.default.errorAndThrow(`Node version must be ${MIN_NODE_VERSION}. Currently ${version.version}`);
+    throw new Error(`Node version must be at least ${MIN_NODE_VERSION}; current is ${version.version}`);
+  }
+}
+
+async function checkNpmOk() {
+  const npmVersion = await getNpmVersion();
+
+  if (!_semver.default.satisfies(npmVersion, MIN_NPM_VERSION)) {
+    throw new Error(`npm version must be at least ${MIN_NPM_VERSION}; current is ${npmVersion}. Run "npm install -g npm" to upgrade.`);
   }
 }
 
@@ -235,4 +250,4 @@ async function validateTmpDir(tmpDir) {
 const rootDir = _support.fs.findRoot(__dirname);
 
 exports.rootDir = rootDir;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["npmPackage","fs","readPackageJsonFrom","__dirname","APPIUM_VER","version","MIN_NODE_VERSION","engines","node","GIT_META_ROOT","GIT_BINARY","system","isWindows","GITHUB_API","BUILD_INFO","getNodeVersion","semver","coerce","process","updateBuildInfo","useGithubApiFallback","sha","getGitRev","buildTimestamp","getGitTimestamp","built","findGitRoot","findUp","cwd","rootDir","type","gitRoot","stdout","exec","trim","ign","axios","get","headers","data","object","commitSha","tagger","date","getBuildInfo","checkNodeOk","satisfies","logger","errorAndThrow","warnNodeDeprecations","showBuildInfo","console","log","JSON","stringify","getNonDefaultServerArgs","parsedArgs","flatten","args","argSpecs","getAllArgSpecs","flattened","_","reduce","values","acc","argSpec","has","dest","value","typesDiffer","defaultsFromSchema","defaultValueIsArray","isArray","argsValueIsArray","arraysDiffer","gt","size","difference","valuesDiffer","defaultIsDefined","isUndefined","argValueNotArrayOrArraysDiffer","overSome","negate","defaultValueNotArrayAndValuesDiffer","overEvery","isNotDefault","getDefaultsForSchema","pickBy","__","key","set","compactConfig","partial","omitBy","isObject","isEmpty","showConfig","nonDefaultPreConfigParsedArgs","configResult","defaults","dir","config","filepath","validateTmpDir","tmpDir","mkdirp","e","Error","findRoot"],"sources":["../../lib/config.js"],"sourcesContent":["/* eslint-disable no-console */\nimport _ from 'lodash';\nimport {system, fs} from '@appium/support';\nimport axios from 'axios';\nimport {exec} from 'teen_process';\nimport logger from './logger';\nimport semver from 'semver';\nimport findUp from 'find-up';\nimport {getDefaultsForSchema, getAllArgSpecs} from './schema/schema';\n\nconst npmPackage = fs.readPackageJsonFrom(__dirname);\n\nconst APPIUM_VER = npmPackage.version;\nconst MIN_NODE_VERSION = npmPackage.engines.node;\n\nconst GIT_META_ROOT = '.git';\nconst GIT_BINARY = `git${system.isWindows() ? '.exe' : ''}`;\nconst GITHUB_API = 'https://api.github.com/repos/appium/appium';\n\n/**\n * @type {import('appium/types').BuildInfo}\n */\nconst BUILD_INFO = {\n  version: APPIUM_VER,\n};\n\nfunction getNodeVersion() {\n  return /** @type {import('semver').SemVer} */ (semver.coerce(process.version));\n}\n\n/**\n * @param {boolean} [useGithubApiFallback]\n */\nasync function updateBuildInfo(useGithubApiFallback = false) {\n  const sha = await getGitRev(useGithubApiFallback);\n  if (!sha) {\n    return;\n  }\n  BUILD_INFO['git-sha'] = sha;\n  const buildTimestamp = await getGitTimestamp(sha, useGithubApiFallback);\n  if (buildTimestamp) {\n    BUILD_INFO.built = buildTimestamp;\n  }\n}\n\n/**\n * Finds the Git metadata dir (see `GIT_META_ROOT`)\n *\n * This is needed because Appium cannot assume `package.json` and `.git` are in the same\n * directory.  Monorepos, see?\n * @returns {Promise<string|undefined>} Path to dir or `undefined` if not found\n */\nasync function findGitRoot() {\n  return await findUp(GIT_META_ROOT, {cwd: rootDir, type: 'directory'});\n}\n\n/**\n * @param {boolean} [useGithubApiFallback]\n * @returns {Promise<string?>}\n */\nasync function getGitRev(useGithubApiFallback = false) {\n  const gitRoot = await findGitRoot();\n  if (gitRoot) {\n    try {\n      const {stdout} = await exec(GIT_BINARY, ['rev-parse', 'HEAD'], {\n        cwd: gitRoot,\n      });\n      return stdout.trim();\n    } catch (ign) {}\n  }\n\n  if (!useGithubApiFallback) {\n    return null;\n  }\n\n  // If the package folder is not a valid git repository\n  // then fetch the corresponding tag info from GitHub\n  try {\n    return (\n      await axios.get(`${GITHUB_API}/git/refs/tags/appium@${APPIUM_VER}`, {\n        headers: {\n          'User-Agent': `Appium ${APPIUM_VER}`,\n        },\n      })\n    ).data?.object?.sha;\n  } catch (ign) {}\n  return null;\n}\n\n/**\n * @param {string} commitSha\n * @param {boolean} [useGithubApiFallback]\n * @returns {Promise<string?>}\n */\nasync function getGitTimestamp(commitSha, useGithubApiFallback = false) {\n  const gitRoot = await findGitRoot();\n  if (gitRoot) {\n    try {\n      const {stdout} = await exec(GIT_BINARY, ['show', '-s', '--format=%ci', commitSha], {\n        cwd: gitRoot,\n      });\n      return stdout.trim();\n    } catch (ign) {}\n  }\n\n  if (!useGithubApiFallback) {\n    return null;\n  }\n\n  try {\n    return (\n      await axios.get(`${GITHUB_API}/git/tags/${commitSha}`, {\n        headers: {\n          'User-Agent': `Appium ${APPIUM_VER}`,\n        },\n      })\n    ).data?.tagger?.date;\n  } catch (ign) {}\n  return null;\n}\n\n/**\n * Mutable object containing Appium build information. By default it\n * only contains the Appium version, but is updated with the build timestamp\n * and git commit hash asynchronously as soon as `updateBuildInfo` is called\n * and succeeds.\n * @returns {import('appium/types').BuildInfo}\n */\nfunction getBuildInfo() {\n  return BUILD_INFO;\n}\n\nfunction checkNodeOk() {\n  const version = getNodeVersion();\n  if (!semver.satisfies(version, MIN_NODE_VERSION)) {\n    logger.errorAndThrow(`Node version must be ${MIN_NODE_VERSION}. Currently ${version.version}`);\n  }\n}\n\nfunction warnNodeDeprecations() {\n  /**\n   * Uncomment this section to get node version deprecation warnings\n   * Also add test cases to config-specs.js to cover the cases added\n   **/\n  // const version = getNodeVersion();\n  // if (version.major < 8) {\n  //   logger.warn(`Appium support for versions of node < ${version.major} has been ` +\n  //               'deprecated and will be removed in a future version. Please ' +\n  //               'upgrade!');\n  // }\n}\n\nasync function showBuildInfo() {\n  await updateBuildInfo(true);\n  console.log(JSON.stringify(getBuildInfo())); // eslint-disable-line no-console\n}\n\n/**\n * Returns k/v pairs of server arguments which are _not_ the defaults.\n * @param {Args} parsedArgs\n * @returns {Args}\n */\nfunction getNonDefaultServerArgs(parsedArgs) {\n  /**\n   * Flattens parsed args into a single level object for comparison with\n   * flattened defaults across server args and extension args.\n   * @param {Args} args\n   * @returns {Record<string, { value: any, argSpec: ArgSpec }>}\n   */\n  const flatten = (args) => {\n    const argSpecs = getAllArgSpecs();\n    const flattened = _.reduce(\n      [...argSpecs.values()],\n      (acc, argSpec) => {\n        if (_.has(args, argSpec.dest)) {\n          acc[argSpec.dest] = {value: _.get(args, argSpec.dest), argSpec};\n        }\n        return acc;\n      },\n      /** @type {Record<string, { value: any, argSpec: ArgSpec }>} */ ({})\n    );\n\n    return flattened;\n  };\n\n  const args = flatten(parsedArgs);\n\n  // hopefully these function names are descriptive enough\n  const typesDiffer = /** @param {string} dest */ (dest) =>\n    typeof args[dest].value !== typeof defaultsFromSchema[dest];\n\n  const defaultValueIsArray = /** @param {string} dest */ (dest) =>\n    _.isArray(defaultsFromSchema[dest]);\n\n  const argsValueIsArray = /** @param {string} dest */ (dest) => _.isArray(args[dest].value);\n\n  const arraysDiffer = /** @param {string} dest */ (dest) =>\n    _.gt(_.size(_.difference(args[dest].value, defaultsFromSchema[dest])), 0);\n\n  const valuesDiffer = /** @param {string} dest */ (dest) =>\n    args[dest].value !== defaultsFromSchema[dest];\n\n  const defaultIsDefined = /** @param {string} dest */ (dest) =>\n    !_.isUndefined(defaultsFromSchema[dest]);\n\n  // note that `_.overEvery` is like an \"AND\", and `_.overSome` is like an \"OR\"\n\n  const argValueNotArrayOrArraysDiffer = _.overSome([_.negate(argsValueIsArray), arraysDiffer]);\n\n  const defaultValueNotArrayAndValuesDiffer = _.overEvery([\n    _.negate(defaultValueIsArray),\n    valuesDiffer,\n  ]);\n\n  /**\n   * This used to be a hideous conditional, but it's broken up into a hideous function instead.\n   * hopefully this makes things a little more understandable.\n   * - checks if the default value is defined\n   * - if so, and the default is not an array:\n   *   - ensures the types are the same\n   *   - ensures the values are equal\n   * - if so, and the default is an array:\n   *   - ensures the args value is an array\n   *   - ensures the args values do not differ from the default values\n   * @type {(dest: string) => boolean}\n   */\n  const isNotDefault = _.overEvery([\n    defaultIsDefined,\n    _.overSome([\n      typesDiffer,\n      _.overEvery([defaultValueIsArray, argValueNotArrayOrArraysDiffer]),\n      defaultValueNotArrayAndValuesDiffer,\n    ]),\n  ]);\n\n  const defaultsFromSchema = getDefaultsForSchema(true);\n\n  return _.reduce(\n    _.pickBy(args, (__, key) => isNotDefault(key)),\n    // explodes the flattened object back into nested one\n    (acc, {value, argSpec}) => _.set(acc, argSpec.dest, value),\n    /** @type {Args} */ ({})\n  );\n}\n\n/**\n * Compacts an object for {@link showConfig}:\n * 1. Removes `subcommand` key/value\n * 2. Removes `undefined` values\n * 3. Removes empty objects (but not `false` values)\n * Does not operate recursively.\n */\nconst compactConfig = _.partial(\n  _.omitBy,\n  _,\n  (value, key) =>\n    key === 'subcommand' || _.isUndefined(value) || (_.isObject(value) && _.isEmpty(value))\n);\n\n/**\n * Shows a breakdown of the current config after CLI params, config file loaded & defaults applied.\n *\n * The actual shape of `preConfigParsedArgs` and `defaults` does not matter for the purposes of this function,\n * but it's intended to be called with values of type {@link ParsedArgs} and `DefaultValues<true>`, respectively.\n *\n * @param {Partial<ParsedArgs>} nonDefaultPreConfigParsedArgs - Parsed CLI args (or param to `init()`) before config & defaults applied\n * @param {import('./config-file').ReadConfigFileResult} configResult - Result of attempting to load a config file.  _Must_ be normalized\n * @param {Partial<ParsedArgs>} defaults - Configuration defaults from schemas\n * @param {ParsedArgs} parsedArgs - Entire parsed args object\n */\nfunction showConfig(nonDefaultPreConfigParsedArgs, configResult, defaults, parsedArgs) {\n  console.log('Appium Configuration\\n');\n  console.log('from defaults:\\n');\n  console.dir(compactConfig(defaults));\n  if (configResult.config) {\n    console.log(`\\nfrom config file at ${configResult.filepath}:\\n`);\n    console.dir(compactConfig(configResult.config));\n  } else {\n    console.log(`\\n(no configuration file loaded)`);\n  }\n  if (_.isEmpty(nonDefaultPreConfigParsedArgs)) {\n    console.log(`\\n(no CLI parameters provided)`);\n  } else {\n    console.log('\\nvia CLI or function call:\\n');\n    console.dir(compactConfig(nonDefaultPreConfigParsedArgs));\n  }\n  console.log('\\nfinal configuration:\\n');\n  console.dir(compactConfig(parsedArgs));\n}\n\n/**\n * @param {string} tmpDir\n */\nasync function validateTmpDir(tmpDir) {\n  try {\n    await fs.mkdirp(tmpDir);\n  } catch (e) {\n    throw new Error(\n      `We could not ensure that the temp dir you specified ` +\n        `(${tmpDir}) exists. Please make sure it's writeable.`\n    );\n  }\n}\n\nconst rootDir = fs.findRoot(__dirname);\n\nexport {\n  getBuildInfo,\n  checkNodeOk,\n  showBuildInfo,\n  warnNodeDeprecations,\n  validateTmpDir,\n  getNonDefaultServerArgs,\n  getGitRev,\n  APPIUM_VER,\n  updateBuildInfo,\n  showConfig,\n  rootDir,\n};\n\n/**\n * @typedef {import('appium/types').ParsedArgs} ParsedArgs\n * @typedef {import('appium/types').Args} Args\n * @typedef {import('./schema/arg-spec').ArgSpec} ArgSpec\n */\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["npmPackage","fs","readPackageJsonFrom","__dirname","APPIUM_VER","version","MIN_NODE_VERSION","engines","node","MIN_NPM_VERSION","npm","GIT_META_ROOT","GIT_BINARY","system","isWindows","GITHUB_API","BUILD_INFO","getNodeVersion","semver","coerce","process","getNpmVersion","stdout","exec","trim","updateBuildInfo","useGithubApiFallback","sha","getGitRev","buildTimestamp","getGitTimestamp","built","findGitRoot","findUp","cwd","rootDir","type","gitRoot","ign","axios","get","headers","data","object","commitSha","tagger","date","getBuildInfo","checkNodeOk","satisfies","Error","checkNpmOk","npmVersion","warnNodeDeprecations","showBuildInfo","console","log","JSON","stringify","getNonDefaultServerArgs","parsedArgs","flatten","args","argSpecs","getAllArgSpecs","flattened","_","reduce","values","acc","argSpec","has","dest","value","typesDiffer","defaultsFromSchema","defaultValueIsArray","isArray","argsValueIsArray","arraysDiffer","gt","size","difference","valuesDiffer","defaultIsDefined","isUndefined","argValueNotArrayOrArraysDiffer","overSome","negate","defaultValueNotArrayAndValuesDiffer","overEvery","isNotDefault","getDefaultsForSchema","pickBy","__","key","set","compactConfig","partial","omitBy","isObject","isEmpty","showConfig","nonDefaultPreConfigParsedArgs","configResult","defaults","dir","config","filepath","validateTmpDir","tmpDir","mkdirp","e","findRoot"],"sources":["../../lib/config.js"],"sourcesContent":["/* eslint-disable no-console */\nimport _ from 'lodash';\nimport {system, fs} from '@appium/support';\nimport axios from 'axios';\nimport {exec} from 'teen_process';\nimport semver from 'semver';\nimport findUp from 'find-up';\nimport {getDefaultsForSchema, getAllArgSpecs} from './schema/schema';\n\nconst npmPackage = fs.readPackageJsonFrom(__dirname);\n\nconst APPIUM_VER = npmPackage.version;\nconst MIN_NODE_VERSION = npmPackage.engines.node;\nconst MIN_NPM_VERSION = npmPackage.engines.npm;\n\nconst GIT_META_ROOT = '.git';\nconst GIT_BINARY = `git${system.isWindows() ? '.exe' : ''}`;\nconst GITHUB_API = 'https://api.github.com/repos/appium/appium';\n\n/**\n * @type {import('appium/types').BuildInfo}\n */\nconst BUILD_INFO = {\n  version: APPIUM_VER,\n};\n\nfunction getNodeVersion() {\n  return /** @type {import('semver').SemVer} */ (semver.coerce(process.version));\n}\n\n/**\n * Returns version of `npm`\n * @returns {Promise<string>}\n */\nasync function getNpmVersion() {\n  const {stdout} = await exec(system.isWindows() ? 'npm.cmd' : 'npm', ['--version']);\n  return stdout.trim();\n}\n\n/**\n * @param {boolean} [useGithubApiFallback]\n */\nasync function updateBuildInfo(useGithubApiFallback = false) {\n  const sha = await getGitRev(useGithubApiFallback);\n  if (!sha) {\n    return;\n  }\n  BUILD_INFO['git-sha'] = sha;\n  const buildTimestamp = await getGitTimestamp(sha, useGithubApiFallback);\n  if (buildTimestamp) {\n    BUILD_INFO.built = buildTimestamp;\n  }\n}\n\n/**\n * Finds the Git metadata dir (see `GIT_META_ROOT`)\n *\n * This is needed because Appium cannot assume `package.json` and `.git` are in the same\n * directory.  Monorepos, see?\n * @returns {Promise<string|undefined>} Path to dir or `undefined` if not found\n */\nasync function findGitRoot() {\n  return await findUp(GIT_META_ROOT, {cwd: rootDir, type: 'directory'});\n}\n\n/**\n * @param {boolean} [useGithubApiFallback]\n * @returns {Promise<string?>}\n */\nasync function getGitRev(useGithubApiFallback = false) {\n  const gitRoot = await findGitRoot();\n  if (gitRoot) {\n    try {\n      const {stdout} = await exec(GIT_BINARY, ['rev-parse', 'HEAD'], {\n        cwd: gitRoot,\n      });\n      return stdout.trim();\n    } catch (ign) {}\n  }\n\n  if (!useGithubApiFallback) {\n    return null;\n  }\n\n  // If the package folder is not a valid git repository\n  // then fetch the corresponding tag info from GitHub\n  try {\n    return (\n      await axios.get(`${GITHUB_API}/git/refs/tags/appium@${APPIUM_VER}`, {\n        headers: {\n          'User-Agent': `Appium ${APPIUM_VER}`,\n        },\n      })\n    ).data?.object?.sha;\n  } catch (ign) {}\n  return null;\n}\n\n/**\n * @param {string} commitSha\n * @param {boolean} [useGithubApiFallback]\n * @returns {Promise<string?>}\n */\nasync function getGitTimestamp(commitSha, useGithubApiFallback = false) {\n  const gitRoot = await findGitRoot();\n  if (gitRoot) {\n    try {\n      const {stdout} = await exec(GIT_BINARY, ['show', '-s', '--format=%ci', commitSha], {\n        cwd: gitRoot,\n      });\n      return stdout.trim();\n    } catch (ign) {}\n  }\n\n  if (!useGithubApiFallback) {\n    return null;\n  }\n\n  try {\n    return (\n      await axios.get(`${GITHUB_API}/git/tags/${commitSha}`, {\n        headers: {\n          'User-Agent': `Appium ${APPIUM_VER}`,\n        },\n      })\n    ).data?.tagger?.date;\n  } catch (ign) {}\n  return null;\n}\n\n/**\n * Mutable object containing Appium build information. By default it\n * only contains the Appium version, but is updated with the build timestamp\n * and git commit hash asynchronously as soon as `updateBuildInfo` is called\n * and succeeds.\n * @returns {import('appium/types').BuildInfo}\n */\nfunction getBuildInfo() {\n  return BUILD_INFO;\n}\n\nfunction checkNodeOk() {\n  const version = getNodeVersion();\n  if (!semver.satisfies(version, MIN_NODE_VERSION)) {\n    throw new Error(\n      `Node version must be at least ${MIN_NODE_VERSION}; current is ${version.version}`\n    );\n  }\n}\n\nexport async function checkNpmOk() {\n  const npmVersion = await getNpmVersion();\n  if (!semver.satisfies(npmVersion, MIN_NPM_VERSION)) {\n    throw new Error(\n      `npm version must be at least ${MIN_NPM_VERSION}; current is ${npmVersion}. Run \"npm install -g npm\" to upgrade.`\n    );\n  }\n}\n\nfunction warnNodeDeprecations() {\n  /**\n   * Uncomment this section to get node version deprecation warnings\n   * Also add test cases to config-specs.js to cover the cases added\n   **/\n  // const version = getNodeVersion();\n  // if (version.major < 8) {\n  //   logger.warn(`Appium support for versions of node < ${version.major} has been ` +\n  //               'deprecated and will be removed in a future version. Please ' +\n  //               'upgrade!');\n  // }\n}\n\nasync function showBuildInfo() {\n  await updateBuildInfo(true);\n  console.log(JSON.stringify(getBuildInfo())); // eslint-disable-line no-console\n}\n\n/**\n * Returns k/v pairs of server arguments which are _not_ the defaults.\n * @param {Args} parsedArgs\n * @returns {Args}\n */\nfunction getNonDefaultServerArgs(parsedArgs) {\n  /**\n   * Flattens parsed args into a single level object for comparison with\n   * flattened defaults across server args and extension args.\n   * @param {Args} args\n   * @returns {Record<string, { value: any, argSpec: ArgSpec }>}\n   */\n  const flatten = (args) => {\n    const argSpecs = getAllArgSpecs();\n    const flattened = _.reduce(\n      [...argSpecs.values()],\n      (acc, argSpec) => {\n        if (_.has(args, argSpec.dest)) {\n          acc[argSpec.dest] = {value: _.get(args, argSpec.dest), argSpec};\n        }\n        return acc;\n      },\n      /** @type {Record<string, { value: any, argSpec: ArgSpec }>} */ ({})\n    );\n\n    return flattened;\n  };\n\n  const args = flatten(parsedArgs);\n\n  // hopefully these function names are descriptive enough\n  const typesDiffer = /** @param {string} dest */ (dest) =>\n    typeof args[dest].value !== typeof defaultsFromSchema[dest];\n\n  const defaultValueIsArray = /** @param {string} dest */ (dest) =>\n    _.isArray(defaultsFromSchema[dest]);\n\n  const argsValueIsArray = /** @param {string} dest */ (dest) => _.isArray(args[dest].value);\n\n  const arraysDiffer = /** @param {string} dest */ (dest) =>\n    _.gt(_.size(_.difference(args[dest].value, defaultsFromSchema[dest])), 0);\n\n  const valuesDiffer = /** @param {string} dest */ (dest) =>\n    args[dest].value !== defaultsFromSchema[dest];\n\n  const defaultIsDefined = /** @param {string} dest */ (dest) =>\n    !_.isUndefined(defaultsFromSchema[dest]);\n\n  // note that `_.overEvery` is like an \"AND\", and `_.overSome` is like an \"OR\"\n\n  const argValueNotArrayOrArraysDiffer = _.overSome([_.negate(argsValueIsArray), arraysDiffer]);\n\n  const defaultValueNotArrayAndValuesDiffer = _.overEvery([\n    _.negate(defaultValueIsArray),\n    valuesDiffer,\n  ]);\n\n  /**\n   * This used to be a hideous conditional, but it's broken up into a hideous function instead.\n   * hopefully this makes things a little more understandable.\n   * - checks if the default value is defined\n   * - if so, and the default is not an array:\n   *   - ensures the types are the same\n   *   - ensures the values are equal\n   * - if so, and the default is an array:\n   *   - ensures the args value is an array\n   *   - ensures the args values do not differ from the default values\n   * @type {(dest: string) => boolean}\n   */\n  const isNotDefault = _.overEvery([\n    defaultIsDefined,\n    _.overSome([\n      typesDiffer,\n      _.overEvery([defaultValueIsArray, argValueNotArrayOrArraysDiffer]),\n      defaultValueNotArrayAndValuesDiffer,\n    ]),\n  ]);\n\n  const defaultsFromSchema = getDefaultsForSchema(true);\n\n  return _.reduce(\n    _.pickBy(args, (__, key) => isNotDefault(key)),\n    // explodes the flattened object back into nested one\n    (acc, {value, argSpec}) => _.set(acc, argSpec.dest, value),\n    /** @type {Args} */ ({})\n  );\n}\n\n/**\n * Compacts an object for {@link showConfig}:\n * 1. Removes `subcommand` key/value\n * 2. Removes `undefined` values\n * 3. Removes empty objects (but not `false` values)\n * Does not operate recursively.\n */\nconst compactConfig = _.partial(\n  _.omitBy,\n  _,\n  (value, key) =>\n    key === 'subcommand' || _.isUndefined(value) || (_.isObject(value) && _.isEmpty(value))\n);\n\n/**\n * Shows a breakdown of the current config after CLI params, config file loaded & defaults applied.\n *\n * The actual shape of `preConfigParsedArgs` and `defaults` does not matter for the purposes of this function,\n * but it's intended to be called with values of type {@link ParsedArgs} and `DefaultValues<true>`, respectively.\n *\n * @param {Partial<ParsedArgs>} nonDefaultPreConfigParsedArgs - Parsed CLI args (or param to `init()`) before config & defaults applied\n * @param {import('./config-file').ReadConfigFileResult} configResult - Result of attempting to load a config file.  _Must_ be normalized\n * @param {Partial<ParsedArgs>} defaults - Configuration defaults from schemas\n * @param {ParsedArgs} parsedArgs - Entire parsed args object\n */\nfunction showConfig(nonDefaultPreConfigParsedArgs, configResult, defaults, parsedArgs) {\n  console.log('Appium Configuration\\n');\n  console.log('from defaults:\\n');\n  console.dir(compactConfig(defaults));\n  if (configResult.config) {\n    console.log(`\\nfrom config file at ${configResult.filepath}:\\n`);\n    console.dir(compactConfig(configResult.config));\n  } else {\n    console.log(`\\n(no configuration file loaded)`);\n  }\n  if (_.isEmpty(nonDefaultPreConfigParsedArgs)) {\n    console.log(`\\n(no CLI parameters provided)`);\n  } else {\n    console.log('\\nvia CLI or function call:\\n');\n    console.dir(compactConfig(nonDefaultPreConfigParsedArgs));\n  }\n  console.log('\\nfinal configuration:\\n');\n  console.dir(compactConfig(parsedArgs));\n}\n\n/**\n * @param {string} tmpDir\n */\nasync function validateTmpDir(tmpDir) {\n  try {\n    await fs.mkdirp(tmpDir);\n  } catch (e) {\n    throw new Error(\n      `We could not ensure that the temp dir you specified ` +\n        `(${tmpDir}) exists. Please make sure it's writeable.`\n    );\n  }\n}\n\nconst rootDir = fs.findRoot(__dirname);\n\nexport {\n  getBuildInfo,\n  checkNodeOk,\n  showBuildInfo,\n  warnNodeDeprecations,\n  validateTmpDir,\n  getNonDefaultServerArgs,\n  getGitRev,\n  APPIUM_VER,\n  updateBuildInfo,\n  showConfig,\n  rootDir,\n};\n\n/**\n * @typedef {import('appium/types').ParsedArgs} ParsedArgs\n * @typedef {import('appium/types').Args} Args\n * @typedef {import('./schema/arg-spec').ArgSpec} ArgSpec\n */\n"],"mappings":"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"}

package/build/lib/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../lib/main.js"],"names":[],"mappings":";;yBAiZa,OAAO,eAAe,EAAE,UAAU;yBAClC,OAAO,eAAe,EAAE,UAAU;0BAClC,OAAO,eAAe,EAAE,WAAW;0BACnC,OAAO,eAAe,EAAE,WAAW;mCACnC,OAAO,cAAc,EAAE,oBAAoB;4BAC3C,OAAO,aAAa,EAAE,aAAa;4BACnC,OAAO,aAAa,EAAE,aAAa;;;;mCAKlC,EAAE;;;;;kBAKF,OAAO,UAAU,EAAE,YAAY;;;;gBAC/B,OAAO,cAAc,EAAE,UAAU;;+BAIlC,cAAc,GAAG,OAAO,aAAa,EAAE,gBAAgB;oEAKvD,OAAO,cAAc,EAAE,IAAI,CAAC,CAAC,CAAC;0EAK9B,OAAO,cAAc,EAAE,UAAU,CAAC,CAAC,CAAC;AAjJjD;;;;;;GAMG;AACH,mGAFa,QAAQ,OAAO,eAAe,EAAE,YAAY,GAAC,SAAS,CAAC,CA8FnE;AAvOD;;;;;;;;;;;;;;;GAeG;AACH,mGAPa,QAAQ,gBAAgB,GAAG,oBAAoB,CAAC,CAyH5D"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../lib/main.js"],"names":[],"mappings":";;yBA2Ya,OAAO,eAAe,EAAE,UAAU;yBAClC,OAAO,eAAe,EAAE,UAAU;0BAClC,OAAO,eAAe,EAAE,WAAW;0BACnC,OAAO,eAAe,EAAE,WAAW;mCACnC,OAAO,cAAc,EAAE,oBAAoB;4BAC3C,OAAO,aAAa,EAAE,aAAa;4BACnC,OAAO,aAAa,EAAE,aAAa;;;;mCAKlC,EAAE;;;;;kBAKF,OAAO,UAAU,EAAE,YAAY;;;;gBAC/B,OAAO,cAAc,EAAE,UAAU;;+BAIlC,cAAc,GAAG,OAAO,aAAa,EAAE,gBAAgB;oEAKvD,OAAO,cAAc,EAAE,IAAI,CAAC,CAAC,CAAC;0EAK9B,OAAO,cAAc,EAAE,UAAU,CAAC,CAAC,CAAC;AAnJjD;;;;;;GAMG;AACH,mGAFa,QAAQ,OAAO,eAAe,EAAE,YAAY,GAAC,SAAS,CAAC,CAgGnE;AAjOD;;;;;;;;;;;;;;;GAeG;AACH,mGAPa,QAAQ,gBAAgB,GAAG,oBAAoB,CAAC,CAiH5D"}

package/build/lib/main.js

@@ -68,17 +68,15 @@ var _schema = require("./schema/schema");
 
 var _utils = require("./utils");
 
-var _path = _interopRequireDefault(require("path"));
-
 const {
-  resolveAppiumHome,
-  hasAppiumDependency
+  resolveAppiumHome
 } = _support.env;
 exports.resolveAppiumHome = resolveAppiumHome;
 
 async function preflightChecks(args, throwInsteadOfExit = false) {
   try {
     (0, _config.checkNodeOk)();
+    await (0, _config.checkNpmOk)();
 
     if (args.longStacktrace) {
       require('longjohn').async_trace_limit = -1;
@@ -161,18 +159,7 @@ function areServerCommandArgs(args) {
 
 async function init(args) {
   const appiumHome = (args === null || args === void 0 ? void 0 : args.appiumHome) ?? (await resolveAppiumHome());
-
-  if (!(await hasAppiumDependency(appiumHome))) {
-    try {
-      await _support.fs.mkdirp(_path.default.join(appiumHome, 'node_modules'));
-      await _support.fs.symlink(_config.rootDir, _path.default.join(appiumHome, 'node_modules', 'appium'), 'junction');
-    } catch (err) {
-      if (err.code !== 'EEXIST') {
-        throw new Error(`Unable to create symlink to appium: ${err.message}`);
-      }
-    }
-  }
-
+  (0, _utils.adjustNodePath)();
   const {
     driverConfig,
     pluginConfig
@@ -200,19 +187,7 @@ async function init(args) {
     throw new Error(`Errors in config file ${configResult.filepath}:\n ${configResult.reason ?? configResult.errors}`);
   }
 
-  if (!areServerCommandArgs(preConfigArgs)) {
-    if (preConfigArgs.subcommand === _constants.DRIVER_TYPE) {
-      await (0, _extension.runExtensionCommand)(preConfigArgs, driverConfig);
-      return {};
-    }
-
-    if (preConfigArgs.subcommand === _constants.PLUGIN_TYPE) {
-      await (0, _extension.runExtensionCommand)(preConfigArgs, pluginConfig);
-      return {};
-    }
-
-    return {};
-  } else {
+  if (areServerCommandArgs(preConfigArgs)) {
     var _configResult$config;
 
     const defaults = (0, _schema.getDefaultsForSchema)(false);
@@ -252,6 +227,20 @@ async function init(args) {
       driverConfig,
       pluginConfig
     };
+  } else {
+    const extensionCommandArgs = preConfigArgs;
+
+    if (preConfigArgs.subcommand === _constants.DRIVER_TYPE) {
+      await (0, _extension.runExtensionCommand)(extensionCommandArgs, driverConfig);
+      return {};
+    }
+
+    if (preConfigArgs.subcommand === _constants.PLUGIN_TYPE) {
+      await (0, _extension.runExtensionCommand)(extensionCommandArgs, pluginConfig);
+      return {};
+    }
+
+    return {};
   }
 }
 
@@ -281,7 +270,8 @@ async function main(args) {
     allowCors: parsedArgs.allowCors,
     basePath: parsedArgs.basePath,
     serverUpdaters,
-    extraMethodMap
+    extraMethodMap,
+    cliArgs: parsedArgs
   };
 
   if (parsedArgs.keepAliveTimeout) {
@@ -343,4 +333,4 @@ async function main(args) {
 if (require.main === module) {
   (0, _asyncbox.asyncify)(main);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["resolveAppiumHome","hasAppiumDependency","env","preflightChecks","args","throwInsteadOfExit","checkNodeOk","longStacktrace","require","async_trace_limit","showBuildInfo","process","exit","warnNodeDeprecations","validate","tmpDir","validateTmpDir","err","logger","error","message","red","logNonDefaultArgsWarning","info","inspect","logDefaultCapabilitiesWarning","caps","logStartupInfo","welcome","APPIUM_VER","appiumRev","getGitRev","showArgs","getNonDefaultServerArgs","_","size","isEmpty","defaultCapabilities","logServerPort","address","port","logMessage","getServerUpdaters","driverClasses","pluginClasses","compact","map","keys","getExtraMethodMap","reduce","klass","newMethodMap","areServerCommandArgs","subcommand","SERVER_SUBCOMMAND","init","appiumHome","fs","mkdirp","path","join","symlink","rootDir","code","Error","driverConfig","pluginConfig","loadExtensions","parser","getParser","preConfigArgs","parseArgs","configResult","readConfigFile","configFile","errors","filepath","reason","DRIVER_TYPE","runExtensionCommand","PLUGIN_TYPE","defaults","getDefaultsForSchema","serverArgs","defaultsDeep","config","server","showConfig","logsinkInit","logFilters","issues","rules","logFactory","loadSecureValuesPreprocessingRules","JSON","stringify","warn","util","pluralize","length","appiumDriver","AppiumDriver","parsedArgs","main","getActivePlugins","usePlugins","routeConfiguringFunction","makeRouter","getActiveDrivers","useDrivers","serverUpdaters","extraMethodMap","serverOpts","hostname","allowCors","basePath","keepAliveTimeout","baseServer","debug","stack","nodeconfig","registerNode","close","signal","once","onSignal","deleteAllSessions","force","e","print","values","module","asyncify"],"sources":["../../lib/main.js"],"sourcesContent":["#!/usr/bin/env node\n\nimport {init as logsinkInit} from './logsink'; // this import needs to come first since it sets up global npmlog\nimport logger from './logger'; // logger needs to remain second\n// @ts-ignore\nimport {routeConfiguringFunction as makeRouter, server as baseServer} from '@appium/base-driver';\nimport {logger as logFactory, util, env, fs} from '@appium/support';\nimport {asyncify} from 'asyncbox';\nimport _ from 'lodash';\nimport {AppiumDriver} from './appium';\nimport {runExtensionCommand} from './cli/extension';\nimport {getParser} from './cli/parser';\nimport {\n  APPIUM_VER,\n  checkNodeOk,\n  getGitRev,\n  getNonDefaultServerArgs,\n  rootDir,\n  showConfig,\n  showBuildInfo,\n  validateTmpDir,\n  warnNodeDeprecations,\n} from './config';\nimport {readConfigFile} from './config-file';\nimport {loadExtensions, getActivePlugins, getActiveDrivers} from './extension';\nimport {DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND} from './constants';\nimport registerNode from './grid-register';\nimport {getDefaultsForSchema, validate} from './schema/schema';\nimport {inspect} from './utils';\nimport path from 'path';\n\nconst {resolveAppiumHome, hasAppiumDependency} = env;\n\n/**\n *\n * @param {ParsedArgs} args\n * @param {boolean} [throwInsteadOfExit]\n */\nasync function preflightChecks(args, throwInsteadOfExit = false) {\n  try {\n    checkNodeOk();\n    if (args.longStacktrace) {\n      require('longjohn').async_trace_limit = -1;\n    }\n    if (args.showBuildInfo) {\n      await showBuildInfo();\n      process.exit(0);\n    }\n    warnNodeDeprecations();\n\n    validate(args);\n\n    if (args.tmpDir) {\n      await validateTmpDir(args.tmpDir);\n    }\n  } catch (err) {\n    logger.error(err.message.red);\n    if (throwInsteadOfExit) {\n      throw err;\n    }\n\n    process.exit(1);\n  }\n}\n\n/**\n * @param {Args} args\n */\nfunction logNonDefaultArgsWarning(args) {\n  logger.info('Non-default server args:');\n  inspect(args);\n}\n\n/**\n * @param {Args['defaultCapabilities']} caps\n */\nfunction logDefaultCapabilitiesWarning(caps) {\n  logger.info(\n    'Default capabilities, which will be added to each request ' +\n      'unless overridden by desired capabilities:'\n  );\n  inspect(caps);\n}\n\n/**\n * @param {ParsedArgs} args\n */\nasync function logStartupInfo(args) {\n  let welcome = `Welcome to Appium v${APPIUM_VER}`;\n  let appiumRev = await getGitRev();\n  if (appiumRev) {\n    welcome += ` (REV ${appiumRev})`;\n  }\n  logger.info(welcome);\n\n  let showArgs = getNonDefaultServerArgs(args);\n  if (_.size(showArgs)) {\n    logNonDefaultArgsWarning(showArgs);\n  }\n  if (!_.isEmpty(args.defaultCapabilities)) {\n    logDefaultCapabilitiesWarning(args.defaultCapabilities);\n  }\n  // TODO: bring back loglevel reporting below once logger is flushed out\n  // logger.info('Console LogLevel: ' + logger.transports.console.level);\n  // if (logger.transports.file) {\n  //   logger.info('File LogLevel: ' + logger.transports.file.level);\n  // }\n}\n\n/**\n * Logs the address and port the server is listening on\n * @param {string} address - Address\n * @param {number} port - Port\n * @returns {void}\n */\nfunction logServerPort(address, port) {\n  let logMessage = `Appium REST http interface listener started on ` + `${address}:${port}`;\n  logger.info(logMessage);\n}\n\n/**\n * Gets a list of `updateServer` functions from all extensions\n * @param {DriverNameMap} driverClasses\n * @param {PluginNameMap} pluginClasses\n * @returns {import('@appium/types').UpdateServerCallback[]}\n */\nfunction getServerUpdaters(driverClasses, pluginClasses) {\n  return _.compact(_.map([...driverClasses.keys(), ...pluginClasses.keys()], 'updateServer'));\n}\n\n/**\n * Makes a big `MethodMap` from all the little `MethodMap`s in the extensions\n * @param {DriverNameMap} driverClasses\n * @param {PluginNameMap} pluginClasses\n * @returns {import('@appium/types').MethodMap}\n */\nfunction getExtraMethodMap(driverClasses, pluginClasses) {\n  return [...driverClasses.keys(), ...pluginClasses.keys()].reduce(\n    (map, klass) => ({\n      ...map,\n      ...(klass.newMethodMap ?? {}),\n    }),\n    {}\n  );\n}\n\n/**\n * @template [T=WithServerSubcommand]\n * @param {Args<T>} args\n * @returns {args is Args<WithServerSubcommand>}\n */\nfunction areServerCommandArgs(args) {\n  return args.subcommand === SERVER_SUBCOMMAND;\n}\n\n/**\n * Initializes Appium, but does not start the server.\n *\n * Use this to get at the configuration schema.\n *\n * If `args` contains a non-empty `subcommand` which is not `server`, this function will return an empty object.\n *\n * @template [T=WithServerSubcommand]\n * @param {Args<T>} [args] - Partial args (progammatic usage only)\n * @returns {Promise<ServerInitResult | ExtCommandInitResult>}\n * @example\n * import {init, getSchema} from 'appium';\n * const options = {}; // config object\n * await init(options);\n * const schema = getSchema(); // entire config schema including plugins and drivers\n */\nasync function init(args) {\n  const appiumHome = args?.appiumHome ?? (await resolveAppiumHome());\n\n  // this is here so extensions installed in e.g., `~/.appium` can find the peer dependency\n  // of `appium`, which lives wherever it lives (see `rootDir`).\n  if (!(await hasAppiumDependency(appiumHome))) {\n    try {\n      await fs.mkdirp(path.join(appiumHome, 'node_modules'));\n      await fs.symlink(rootDir, path.join(appiumHome, 'node_modules', 'appium'), 'junction');\n    } catch (err) {\n      if (err.code !== 'EEXIST') {\n        throw new Error(`Unable to create symlink to appium: ${err.message}`);\n      }\n    }\n  }\n\n  const {driverConfig, pluginConfig} = await loadExtensions(appiumHome);\n\n  const parser = getParser();\n  let throwInsteadOfExit = false;\n  /** @type {Args<T>} */\n  let preConfigArgs;\n\n  if (args) {\n    // if we have a containing package instead of running as a CLI process,\n    // that package might not appreciate us calling 'process.exit' willy-\n    // nilly, so give it the option to have us throw instead of exit\n    if (args.throwInsteadOfExit) {\n      throwInsteadOfExit = true;\n      // but remove it since it's not a real server arg per se\n      delete args.throwInsteadOfExit;\n    }\n    preConfigArgs = {...args, subcommand: args.subcommand ?? SERVER_SUBCOMMAND};\n  } else {\n    // otherwise parse from CLI\n    preConfigArgs = /** @type {Args<T>} */ (parser.parseArgs());\n  }\n\n  const configResult = await readConfigFile(preConfigArgs.configFile);\n\n  if (!_.isEmpty(configResult.errors)) {\n    throw new Error(\n      `Errors in config file ${configResult.filepath}:\\n ${\n        configResult.reason ?? configResult.errors\n      }`\n    );\n  }\n\n  // merge config and apply defaults.\n  // the order of precendece is:\n  // 1. command line args\n  // 2. config file\n  // 3. defaults from config file.\n  if (!areServerCommandArgs(preConfigArgs)) {\n    // if the user has requested the 'driver' CLI, don't run the normal server,\n    // but instead pass control to the driver CLI\n    if (preConfigArgs.subcommand === DRIVER_TYPE) {\n      await runExtensionCommand(preConfigArgs, driverConfig);\n      return {};\n    }\n    if (preConfigArgs.subcommand === PLUGIN_TYPE) {\n      await runExtensionCommand(preConfigArgs, pluginConfig);\n      return {};\n    }\n    /* istanbul ignore next */\n    return {}; // should never happen\n  } else {\n    const defaults = getDefaultsForSchema(false);\n\n    /** @type {ParsedArgs} */\n    const serverArgs = _.defaultsDeep(preConfigArgs, configResult.config?.server, defaults);\n\n    if (preConfigArgs.showConfig) {\n      showConfig(getNonDefaultServerArgs(preConfigArgs), configResult, defaults, serverArgs);\n      return {};\n    }\n\n    await logsinkInit(serverArgs);\n\n    if (serverArgs.logFilters) {\n      const {issues, rules} = await logFactory.loadSecureValuesPreprocessingRules(\n        serverArgs.logFilters\n      );\n      if (!_.isEmpty(issues)) {\n        throw new Error(\n          `The log filtering rules config '${serverArgs.logFilters}' has issues: ` +\n            JSON.stringify(issues, null, 2)\n        );\n      }\n      if (_.isEmpty(rules)) {\n        logger.warn(\n          `Found no log filtering rules in '${serverArgs.logFilters}'. Is that expected?`\n        );\n      } else {\n        logger.info(\n          `Loaded ${util.pluralize('filtering rule', rules.length, true)} from '${\n            serverArgs.logFilters\n          }'`\n        );\n      }\n    }\n\n    const appiumDriver = new AppiumDriver(serverArgs);\n    // set the config on the umbrella driver so it can match drivers to caps\n    appiumDriver.driverConfig = driverConfig;\n    await preflightChecks(serverArgs, throwInsteadOfExit);\n\n    return /** @type {ServerInitResult} */ ({\n      appiumDriver,\n      parsedArgs: serverArgs,\n      driverConfig,\n      pluginConfig,\n    });\n  }\n}\n\n/**\n * Initializes Appium's config.  Starts server if appropriate and resolves the\n * server instance if so; otherwise resolves w/ `undefined`.\n * @template [T=WithServerSubcommand]\n * @param {Args<T>} [args] - Arguments from CLI or otherwise\n * @returns {Promise<import('@appium/types').AppiumServer|undefined>}\n */\nasync function main(args) {\n  const {appiumDriver, parsedArgs, pluginConfig, driverConfig} = /** @type {ServerInitResult} */ (\n    await init(args)\n  );\n\n  if (!appiumDriver || !parsedArgs || !pluginConfig || !driverConfig) {\n    // if this branch is taken, we've run a different subcommand, so there's nothing\n    // left to do here.\n    return;\n  }\n\n  const pluginClasses = getActivePlugins(pluginConfig, parsedArgs.usePlugins);\n  // set the active plugins on the umbrella driver so it can use them for commands\n  appiumDriver.pluginClasses = pluginClasses;\n\n  await logStartupInfo(parsedArgs);\n  let routeConfiguringFunction = makeRouter(appiumDriver);\n\n  const driverClasses = getActiveDrivers(driverConfig, parsedArgs.useDrivers);\n  const serverUpdaters = getServerUpdaters(driverClasses, pluginClasses);\n  const extraMethodMap = getExtraMethodMap(driverClasses, pluginClasses);\n\n  const serverOpts = {\n    routeConfiguringFunction,\n    port: parsedArgs.port,\n    hostname: parsedArgs.address,\n    allowCors: parsedArgs.allowCors,\n    basePath: parsedArgs.basePath,\n    serverUpdaters,\n    extraMethodMap,\n  };\n  if (parsedArgs.keepAliveTimeout) {\n    serverOpts.keepAliveTimeout = parsedArgs.keepAliveTimeout * 1000;\n  }\n  let server;\n  try {\n    server = await baseServer(serverOpts);\n  } catch (err) {\n    logger.error(\n      `Could not configure Appium server. It's possible that a driver or plugin tried ` +\n        `to update the server and failed. Original error: ${err.message}`\n    );\n    logger.debug(err.stack);\n    return process.exit(1);\n  }\n\n  if (parsedArgs.allowCors) {\n    logger.warn(\n      'You have enabled CORS requests from any host. Be careful not ' +\n        'to visit sites which could maliciously try to start Appium ' +\n        'sessions on your machine'\n    );\n  }\n  appiumDriver.server = server;\n  try {\n    // configure as node on grid, if necessary\n    // falsy values should not cause this to run\n    if (parsedArgs.nodeconfig) {\n      await registerNode(\n        parsedArgs.nodeconfig,\n        parsedArgs.address,\n        parsedArgs.port,\n        parsedArgs.basePath\n      );\n    }\n  } catch (err) {\n    await server.close();\n    throw err;\n  }\n\n  for (const signal of ['SIGINT', 'SIGTERM']) {\n    process.once(signal, async function onSignal() {\n      logger.info(`Received ${signal} - shutting down`);\n      try {\n        await appiumDriver.deleteAllSessions({\n          force: true,\n          reason: `The process has received ${signal} signal`,\n        });\n        await server.close();\n        process.exit(0);\n      } catch (e) {\n        logger.warn(e);\n        process.exit(1);\n      }\n    });\n  }\n\n  logServerPort(parsedArgs.address, parsedArgs.port);\n  driverConfig.print();\n  pluginConfig.print([...pluginClasses.values()]);\n\n  return server;\n}\n\n// NOTE: this is here for backwards compat for any scripts referencing `main.js` directly\n// (more specifically, `build/lib/main.js`)\n// the executable is now `../index.js`, so that module will typically be `require.main`.\nif (require.main === module) {\n  asyncify(main);\n}\n\n// everything below here is intended to be a public API.\nexport {readConfigFile} from './config-file';\nexport {finalizeSchema, getSchema, validate} from './schema/schema';\nexport {main, init, resolveAppiumHome};\n\n/**\n * @typedef {import('@appium/types').DriverType} DriverType\n * @typedef {import('@appium/types').PluginType} PluginType\n * @typedef {import('@appium/types').DriverClass} DriverClass\n * @typedef {import('@appium/types').PluginClass} PluginClass\n * @typedef {import('appium/types').WithServerSubcommand} WithServerSubcommand\n * @typedef {import('./extension').DriverNameMap} DriverNameMap\n * @typedef {import('./extension').PluginNameMap} PluginNameMap\n */\n\n/**\n * Literally an empty object\n * @typedef { {} } ExtCommandInitResult\n */\n\n/**\n * @typedef ServerInitData\n * @property {import('./appium').AppiumDriver} appiumDriver - The Appium driver\n * @property {import('appium/types').ParsedArgs} parsedArgs - The parsed arguments\n */\n\n/**\n * @typedef {ServerInitData & import('./extension').ExtensionConfigs} ServerInitResult\n */\n\n/**\n * @template [T=WithServerSubcommand]\n * @typedef {import('appium/types').Args<T>} Args\n */\n\n/**\n * @template [T=WithServerSubcommand]\n * @typedef {import('appium/types').ParsedArgs<T>} ParsedArgs\n */\n"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA;;AACA;;AAEA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAWA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAEA,MAAM;EAACA,iBAAD;EAAoBC;AAApB,IAA2CC,YAAjD;;;AAOA,eAAeC,eAAf,CAA+BC,IAA/B,EAAqCC,kBAAkB,GAAG,KAA1D,EAAiE;EAC/D,IAAI;IACF,IAAAC,mBAAA;;IACA,IAAIF,IAAI,CAACG,cAAT,EAAyB;MACvBC,OAAO,CAAC,UAAD,CAAP,CAAoBC,iBAApB,GAAwC,CAAC,CAAzC;IACD;;IACD,IAAIL,IAAI,CAACM,aAAT,EAAwB;MACtB,MAAM,IAAAA,qBAAA,GAAN;MACAC,OAAO,CAACC,IAAR,CAAa,CAAb;IACD;;IACD,IAAAC,4BAAA;IAEA,IAAAC,gBAAA,EAASV,IAAT;;IAEA,IAAIA,IAAI,CAACW,MAAT,EAAiB;MACf,MAAM,IAAAC,sBAAA,EAAeZ,IAAI,CAACW,MAApB,CAAN;IACD;EACF,CAhBD,CAgBE,OAAOE,GAAP,EAAY;IACZC,eAAA,CAAOC,KAAP,CAAaF,GAAG,CAACG,OAAJ,CAAYC,GAAzB;;IACA,IAAIhB,kBAAJ,EAAwB;MACtB,MAAMY,GAAN;IACD;;IAEDN,OAAO,CAACC,IAAR,CAAa,CAAb;EACD;AACF;;AAKD,SAASU,wBAAT,CAAkClB,IAAlC,EAAwC;EACtCc,eAAA,CAAOK,IAAP,CAAY,0BAAZ;;EACA,IAAAC,cAAA,EAAQpB,IAAR;AACD;;AAKD,SAASqB,6BAAT,CAAuCC,IAAvC,EAA6C;EAC3CR,eAAA,CAAOK,IAAP,CACE,+DACE,4CAFJ;;EAIA,IAAAC,cAAA,EAAQE,IAAR;AACD;;AAKD,eAAeC,cAAf,CAA8BvB,IAA9B,EAAoC;EAClC,IAAIwB,OAAO,GAAI,sBAAqBC,kBAAW,EAA/C;EACA,IAAIC,SAAS,GAAG,MAAM,IAAAC,iBAAA,GAAtB;;EACA,IAAID,SAAJ,EAAe;IACbF,OAAO,IAAK,SAAQE,SAAU,GAA9B;EACD;;EACDZ,eAAA,CAAOK,IAAP,CAAYK,OAAZ;;EAEA,IAAII,QAAQ,GAAG,IAAAC,+BAAA,EAAwB7B,IAAxB,CAAf;;EACA,IAAI8B,eAAA,CAAEC,IAAF,CAAOH,QAAP,CAAJ,EAAsB;IACpBV,wBAAwB,CAACU,QAAD,CAAxB;EACD;;EACD,IAAI,CAACE,eAAA,CAAEE,OAAF,CAAUhC,IAAI,CAACiC,mBAAf,CAAL,EAA0C;IACxCZ,6BAA6B,CAACrB,IAAI,CAACiC,mBAAN,CAA7B;EACD;AAMF;;AAQD,SAASC,aAAT,CAAuBC,OAAvB,EAAgCC,IAAhC,EAAsC;EACpC,IAAIC,UAAU,GAAI,iDAAD,GAAqD,GAAEF,OAAQ,IAAGC,IAAK,EAAxF;;EACAtB,eAAA,CAAOK,IAAP,CAAYkB,UAAZ;AACD;;AAQD,SAASC,iBAAT,CAA2BC,aAA3B,EAA0CC,aAA1C,EAAyD;EACvD,OAAOV,eAAA,CAAEW,OAAF,CAAUX,eAAA,CAAEY,GAAF,CAAM,CAAC,GAAGH,aAAa,CAACI,IAAd,EAAJ,EAA0B,GAAGH,aAAa,CAACG,IAAd,EAA7B,CAAN,EAA0D,cAA1D,CAAV,CAAP;AACD;;AAQD,SAASC,iBAAT,CAA2BL,aAA3B,EAA0CC,aAA1C,EAAyD;EACvD,OAAO,CAAC,GAAGD,aAAa,CAACI,IAAd,EAAJ,EAA0B,GAAGH,aAAa,CAACG,IAAd,EAA7B,EAAmDE,MAAnD,CACL,CAACH,GAAD,EAAMI,KAAN,MAAiB,EACf,GAAGJ,GADY;IAEf,IAAII,KAAK,CAACC,YAAN,IAAsB,EAA1B;EAFe,CAAjB,CADK,EAKL,EALK,CAAP;AAOD;;AAOD,SAASC,oBAAT,CAA8BhD,IAA9B,EAAoC;EAClC,OAAOA,IAAI,CAACiD,UAAL,KAAoBC,4BAA3B;AACD;;AAkBD,eAAeC,IAAf,CAAoBnD,IAApB,EAA0B;EACxB,MAAMoD,UAAU,GAAG,CAAApD,IAAI,SAAJ,IAAAA,IAAI,WAAJ,YAAAA,IAAI,CAAEoD,UAAN,MAAqB,MAAMxD,iBAAiB,EAA5C,CAAnB;;EAIA,IAAI,EAAE,MAAMC,mBAAmB,CAACuD,UAAD,CAA3B,CAAJ,EAA8C;IAC5C,IAAI;MACF,MAAMC,WAAA,CAAGC,MAAH,CAAUC,aAAA,CAAKC,IAAL,CAAUJ,UAAV,EAAsB,cAAtB,CAAV,CAAN;MACA,MAAMC,WAAA,CAAGI,OAAH,CAAWC,eAAX,EAAoBH,aAAA,CAAKC,IAAL,CAAUJ,UAAV,EAAsB,cAAtB,EAAsC,QAAtC,CAApB,EAAqE,UAArE,CAAN;IACD,CAHD,CAGE,OAAOvC,GAAP,EAAY;MACZ,IAAIA,GAAG,CAAC8C,IAAJ,KAAa,QAAjB,EAA2B;QACzB,MAAM,IAAIC,KAAJ,CAAW,uCAAsC/C,GAAG,CAACG,OAAQ,EAA7D,CAAN;MACD;IACF;EACF;;EAED,MAAM;IAAC6C,YAAD;IAAeC;EAAf,IAA+B,MAAM,IAAAC,0BAAA,EAAeX,UAAf,CAA3C;EAEA,MAAMY,MAAM,GAAG,IAAAC,iBAAA,GAAf;EACA,IAAIhE,kBAAkB,GAAG,KAAzB;EAEA,IAAIiE,aAAJ;;EAEA,IAAIlE,IAAJ,EAAU;IAIR,IAAIA,IAAI,CAACC,kBAAT,EAA6B;MAC3BA,kBAAkB,GAAG,IAArB;MAEA,OAAOD,IAAI,CAACC,kBAAZ;IACD;;IACDiE,aAAa,GAAG,EAAC,GAAGlE,IAAJ;MAAUiD,UAAU,EAAEjD,IAAI,CAACiD,UAAL,IAAmBC;IAAzC,CAAhB;EACD,CAVD,MAUO;IAELgB,aAAa,GAA2BF,MAAM,CAACG,SAAP,EAAxC;EACD;;EAED,MAAMC,YAAY,GAAG,MAAM,IAAAC,0BAAA,EAAeH,aAAa,CAACI,UAA7B,CAA3B;;EAEA,IAAI,CAACxC,eAAA,CAAEE,OAAF,CAAUoC,YAAY,CAACG,MAAvB,CAAL,EAAqC;IACnC,MAAM,IAAIX,KAAJ,CACH,yBAAwBQ,YAAY,CAACI,QAAS,OAC7CJ,YAAY,CAACK,MAAb,IAAuBL,YAAY,CAACG,MACrC,EAHG,CAAN;EAKD;;EAOD,IAAI,CAACvB,oBAAoB,CAACkB,aAAD,CAAzB,EAA0C;IAGxC,IAAIA,aAAa,CAACjB,UAAd,KAA6ByB,sBAAjC,EAA8C;MAC5C,MAAM,IAAAC,8BAAA,EAAoBT,aAApB,EAAmCL,YAAnC,CAAN;MACA,OAAO,EAAP;IACD;;IACD,IAAIK,aAAa,CAACjB,UAAd,KAA6B2B,sBAAjC,EAA8C;MAC5C,MAAM,IAAAD,8BAAA,EAAoBT,aAApB,EAAmCJ,YAAnC,CAAN;MACA,OAAO,EAAP;IACD;;IAED,OAAO,EAAP;EACD,CAbD,MAaO;IAAA;;IACL,MAAMe,QAAQ,GAAG,IAAAC,4BAAA,EAAqB,KAArB,CAAjB;;IAGA,MAAMC,UAAU,GAAGjD,eAAA,CAAEkD,YAAF,CAAed,aAAf,0BAA8BE,YAAY,CAACa,MAA3C,yDAA8B,qBAAqBC,MAAnD,EAA2DL,QAA3D,CAAnB;;IAEA,IAAIX,aAAa,CAACiB,UAAlB,EAA8B;MAC5B,IAAAA,kBAAA,EAAW,IAAAtD,+BAAA,EAAwBqC,aAAxB,CAAX,EAAmDE,YAAnD,EAAiES,QAAjE,EAA2EE,UAA3E;MACA,OAAO,EAAP;IACD;;IAED,MAAM,IAAAK,aAAA,EAAYL,UAAZ,CAAN;;IAEA,IAAIA,UAAU,CAACM,UAAf,EAA2B;MACzB,MAAM;QAACC,MAAD;QAASC;MAAT,IAAkB,MAAMC,eAAA,CAAWC,kCAAX,CAC5BV,UAAU,CAACM,UADiB,CAA9B;;MAGA,IAAI,CAACvD,eAAA,CAAEE,OAAF,CAAUsD,MAAV,CAAL,EAAwB;QACtB,MAAM,IAAI1B,KAAJ,CACH,mCAAkCmB,UAAU,CAACM,UAAW,gBAAzD,GACEK,IAAI,CAACC,SAAL,CAAeL,MAAf,EAAuB,IAAvB,EAA6B,CAA7B,CAFE,CAAN;MAID;;MACD,IAAIxD,eAAA,CAAEE,OAAF,CAAUuD,KAAV,CAAJ,EAAsB;QACpBzE,eAAA,CAAO8E,IAAP,CACG,oCAAmCb,UAAU,CAACM,UAAW,sBAD5D;MAGD,CAJD,MAIO;QACLvE,eAAA,CAAOK,IAAP,CACG,UAAS0E,aAAA,CAAKC,SAAL,CAAe,gBAAf,EAAiCP,KAAK,CAACQ,MAAvC,EAA+C,IAA/C,CAAqD,UAC7DhB,UAAU,CAACM,UACZ,GAHH;MAKD;IACF;;IAED,MAAMW,YAAY,GAAG,IAAIC,oBAAJ,CAAiBlB,UAAjB,CAArB;IAEAiB,YAAY,CAACnC,YAAb,GAA4BA,YAA5B;IACA,MAAM9D,eAAe,CAACgF,UAAD,EAAa9E,kBAAb,CAArB;IAEA,OAAwC;MACtC+F,YADsC;MAEtCE,UAAU,EAAEnB,UAF0B;MAGtClB,YAHsC;MAItCC;IAJsC,CAAxC;EAMD;AACF;;AASD,eAAeqC,IAAf,CAAoBnG,IAApB,EAA0B;EACxB,MAAM;IAACgG,YAAD;IAAeE,UAAf;IAA2BpC,YAA3B;IAAyCD;EAAzC,IACJ,MAAMV,IAAI,CAACnD,IAAD,CADZ;;EAIA,IAAI,CAACgG,YAAD,IAAiB,CAACE,UAAlB,IAAgC,CAACpC,YAAjC,IAAiD,CAACD,YAAtD,EAAoE;IAGlE;EACD;;EAED,MAAMrB,aAAa,GAAG,IAAA4D,4BAAA,EAAiBtC,YAAjB,EAA+BoC,UAAU,CAACG,UAA1C,CAAtB;EAEAL,YAAY,CAACxD,aAAb,GAA6BA,aAA7B;EAEA,MAAMjB,cAAc,CAAC2E,UAAD,CAApB;EACA,IAAII,wBAAwB,GAAG,IAAAC,oCAAA,EAAWP,YAAX,CAA/B;EAEA,MAAMzD,aAAa,GAAG,IAAAiE,4BAAA,EAAiB3C,YAAjB,EAA+BqC,UAAU,CAACO,UAA1C,CAAtB;EACA,MAAMC,cAAc,GAAGpE,iBAAiB,CAACC,aAAD,EAAgBC,aAAhB,CAAxC;EACA,MAAMmE,cAAc,GAAG/D,iBAAiB,CAACL,aAAD,EAAgBC,aAAhB,CAAxC;EAEA,MAAMoE,UAAU,GAAG;IACjBN,wBADiB;IAEjBlE,IAAI,EAAE8D,UAAU,CAAC9D,IAFA;IAGjByE,QAAQ,EAAEX,UAAU,CAAC/D,OAHJ;IAIjB2E,SAAS,EAAEZ,UAAU,CAACY,SAJL;IAKjBC,QAAQ,EAAEb,UAAU,CAACa,QALJ;IAMjBL,cANiB;IAOjBC;EAPiB,CAAnB;;EASA,IAAIT,UAAU,CAACc,gBAAf,EAAiC;IAC/BJ,UAAU,CAACI,gBAAX,GAA8Bd,UAAU,CAACc,gBAAX,GAA8B,IAA5D;EACD;;EACD,IAAI9B,MAAJ;;EACA,IAAI;IACFA,MAAM,GAAG,MAAM,IAAA+B,kBAAA,EAAWL,UAAX,CAAf;EACD,CAFD,CAEE,OAAO/F,GAAP,EAAY;IACZC,eAAA,CAAOC,KAAP,CACG,iFAAD,GACG,oDAAmDF,GAAG,CAACG,OAAQ,EAFpE;;IAIAF,eAAA,CAAOoG,KAAP,CAAarG,GAAG,CAACsG,KAAjB;;IACA,OAAO5G,OAAO,CAACC,IAAR,CAAa,CAAb,CAAP;EACD;;EAED,IAAI0F,UAAU,CAACY,SAAf,EAA0B;IACxBhG,eAAA,CAAO8E,IAAP,CACE,kEACE,6DADF,GAEE,0BAHJ;EAKD;;EACDI,YAAY,CAACd,MAAb,GAAsBA,MAAtB;;EACA,IAAI;IAGF,IAAIgB,UAAU,CAACkB,UAAf,EAA2B;MACzB,MAAM,IAAAC,qBAAA,EACJnB,UAAU,CAACkB,UADP,EAEJlB,UAAU,CAAC/D,OAFP,EAGJ+D,UAAU,CAAC9D,IAHP,EAIJ8D,UAAU,CAACa,QAJP,CAAN;IAMD;EACF,CAXD,CAWE,OAAOlG,GAAP,EAAY;IACZ,MAAMqE,MAAM,CAACoC,KAAP,EAAN;IACA,MAAMzG,GAAN;EACD;;EAED,KAAK,MAAM0G,MAAX,IAAqB,CAAC,QAAD,EAAW,SAAX,CAArB,EAA4C;IAC1ChH,OAAO,CAACiH,IAAR,CAAaD,MAAb,EAAqB,eAAeE,QAAf,GAA0B;MAC7C3G,eAAA,CAAOK,IAAP,CAAa,YAAWoG,MAAO,kBAA/B;;MACA,IAAI;QACF,MAAMvB,YAAY,CAAC0B,iBAAb,CAA+B;UACnCC,KAAK,EAAE,IAD4B;UAEnClD,MAAM,EAAG,4BAA2B8C,MAAO;QAFR,CAA/B,CAAN;QAIA,MAAMrC,MAAM,CAACoC,KAAP,EAAN;QACA/G,OAAO,CAACC,IAAR,CAAa,CAAb;MACD,CAPD,CAOE,OAAOoH,CAAP,EAAU;QACV9G,eAAA,CAAO8E,IAAP,CAAYgC,CAAZ;;QACArH,OAAO,CAACC,IAAR,CAAa,CAAb;MACD;IACF,CAbD;EAcD;;EAED0B,aAAa,CAACgE,UAAU,CAAC/D,OAAZ,EAAqB+D,UAAU,CAAC9D,IAAhC,CAAb;EACAyB,YAAY,CAACgE,KAAb;EACA/D,YAAY,CAAC+D,KAAb,CAAmB,CAAC,GAAGrF,aAAa,CAACsF,MAAd,EAAJ,CAAnB;EAEA,OAAO5C,MAAP;AACD;;AAKD,IAAI9E,OAAO,CAAC+F,IAAR,KAAiB4B,MAArB,EAA6B;EAC3B,IAAAC,kBAAA,EAAS7B,IAAT;AACD"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["resolveAppiumHome","env","preflightChecks","args","throwInsteadOfExit","checkNodeOk","checkNpmOk","longStacktrace","require","async_trace_limit","showBuildInfo","process","exit","warnNodeDeprecations","validate","tmpDir","validateTmpDir","err","logger","error","message","red","logNonDefaultArgsWarning","info","inspect","logDefaultCapabilitiesWarning","caps","logStartupInfo","welcome","APPIUM_VER","appiumRev","getGitRev","showArgs","getNonDefaultServerArgs","_","size","isEmpty","defaultCapabilities","logServerPort","address","port","logMessage","getServerUpdaters","driverClasses","pluginClasses","compact","map","keys","getExtraMethodMap","reduce","klass","newMethodMap","areServerCommandArgs","subcommand","SERVER_SUBCOMMAND","init","appiumHome","adjustNodePath","driverConfig","pluginConfig","loadExtensions","parser","getParser","preConfigArgs","parseArgs","configResult","readConfigFile","configFile","errors","Error","filepath","reason","defaults","getDefaultsForSchema","serverArgs","defaultsDeep","config","server","showConfig","logsinkInit","logFilters","issues","rules","logFactory","loadSecureValuesPreprocessingRules","JSON","stringify","warn","util","pluralize","length","appiumDriver","AppiumDriver","parsedArgs","extensionCommandArgs","DRIVER_TYPE","runExtensionCommand","PLUGIN_TYPE","main","getActivePlugins","usePlugins","routeConfiguringFunction","makeRouter","getActiveDrivers","useDrivers","serverUpdaters","extraMethodMap","serverOpts","hostname","allowCors","basePath","cliArgs","keepAliveTimeout","baseServer","debug","stack","nodeconfig","registerNode","close","signal","once","onSignal","deleteAllSessions","force","e","print","values","module","asyncify"],"sources":["../../lib/main.js"],"sourcesContent":["#!/usr/bin/env node\n\nimport {init as logsinkInit} from './logsink'; // this import needs to come first since it sets up global npmlog\nimport logger from './logger'; // logger needs to remain second\n// @ts-ignore\nimport {routeConfiguringFunction as makeRouter, server as baseServer} from '@appium/base-driver';\nimport {logger as logFactory, util, env} from '@appium/support';\nimport {asyncify} from 'asyncbox';\nimport _ from 'lodash';\nimport {AppiumDriver} from './appium';\nimport {runExtensionCommand} from './cli/extension';\nimport {getParser} from './cli/parser';\nimport {\n  APPIUM_VER,\n  checkNodeOk,\n  getGitRev,\n  getNonDefaultServerArgs,\n  showConfig,\n  showBuildInfo,\n  validateTmpDir,\n  warnNodeDeprecations,\n  checkNpmOk,\n} from './config';\nimport {readConfigFile} from './config-file';\nimport {loadExtensions, getActivePlugins, getActiveDrivers} from './extension';\nimport {DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND} from './constants';\nimport registerNode from './grid-register';\nimport {getDefaultsForSchema, validate} from './schema/schema';\nimport {inspect, adjustNodePath} from './utils';\n\nconst {resolveAppiumHome} = env;\n\n/**\n *\n * @param {ParsedArgs} args\n * @param {boolean} [throwInsteadOfExit]\n */\nasync function preflightChecks(args, throwInsteadOfExit = false) {\n  try {\n    checkNodeOk();\n    await checkNpmOk();\n    if (args.longStacktrace) {\n      require('longjohn').async_trace_limit = -1;\n    }\n    if (args.showBuildInfo) {\n      await showBuildInfo();\n      process.exit(0);\n    }\n    warnNodeDeprecations();\n\n    validate(args);\n\n    if (args.tmpDir) {\n      await validateTmpDir(args.tmpDir);\n    }\n  } catch (err) {\n    logger.error(err.message.red);\n    if (throwInsteadOfExit) {\n      throw err;\n    }\n\n    process.exit(1);\n  }\n}\n\n/**\n * @param {Args} args\n */\nfunction logNonDefaultArgsWarning(args) {\n  logger.info('Non-default server args:');\n  inspect(args);\n}\n\n/**\n * @param {Args['defaultCapabilities']} caps\n */\nfunction logDefaultCapabilitiesWarning(caps) {\n  logger.info(\n    'Default capabilities, which will be added to each request ' +\n      'unless overridden by desired capabilities:'\n  );\n  inspect(caps);\n}\n\n/**\n * @param {ParsedArgs} args\n */\nasync function logStartupInfo(args) {\n  let welcome = `Welcome to Appium v${APPIUM_VER}`;\n  let appiumRev = await getGitRev();\n  if (appiumRev) {\n    welcome += ` (REV ${appiumRev})`;\n  }\n  logger.info(welcome);\n\n  let showArgs = getNonDefaultServerArgs(args);\n  if (_.size(showArgs)) {\n    logNonDefaultArgsWarning(showArgs);\n  }\n  if (!_.isEmpty(args.defaultCapabilities)) {\n    logDefaultCapabilitiesWarning(args.defaultCapabilities);\n  }\n  // TODO: bring back loglevel reporting below once logger is flushed out\n  // logger.info('Console LogLevel: ' + logger.transports.console.level);\n  // if (logger.transports.file) {\n  //   logger.info('File LogLevel: ' + logger.transports.file.level);\n  // }\n}\n\n/**\n * Logs the address and port the server is listening on\n * @param {string} address - Address\n * @param {number} port - Port\n * @returns {void}\n */\nfunction logServerPort(address, port) {\n  let logMessage = `Appium REST http interface listener started on ` + `${address}:${port}`;\n  logger.info(logMessage);\n}\n\n/**\n * Gets a list of `updateServer` functions from all extensions\n * @param {DriverNameMap} driverClasses\n * @param {PluginNameMap} pluginClasses\n * @returns {import('@appium/types').UpdateServerCallback[]}\n */\nfunction getServerUpdaters(driverClasses, pluginClasses) {\n  return _.compact(_.map([...driverClasses.keys(), ...pluginClasses.keys()], 'updateServer'));\n}\n\n/**\n * Makes a big `MethodMap` from all the little `MethodMap`s in the extensions\n * @param {DriverNameMap} driverClasses\n * @param {PluginNameMap} pluginClasses\n * @returns {import('@appium/types').MethodMap}\n */\nfunction getExtraMethodMap(driverClasses, pluginClasses) {\n  return [...driverClasses.keys(), ...pluginClasses.keys()].reduce(\n    (map, klass) => ({\n      ...map,\n      ...(klass.newMethodMap ?? {}),\n    }),\n    {}\n  );\n}\n\n/**\n * @template [T=WithServerSubcommand]\n * @param {Args<T>} args\n * @returns {args is Args<WithServerSubcommand>}\n */\nfunction areServerCommandArgs(args) {\n  return args.subcommand === SERVER_SUBCOMMAND;\n}\n\n/**\n * Initializes Appium, but does not start the server.\n *\n * Use this to get at the configuration schema.\n *\n * If `args` contains a non-empty `subcommand` which is not `server`, this function will return an empty object.\n *\n * @template [T=WithServerSubcommand]\n * @param {Args<T>} [args] - Partial args (progammatic usage only)\n * @returns {Promise<ServerInitResult | ExtCommandInitResult>}\n * @example\n * import {init, getSchema} from 'appium';\n * const options = {}; // config object\n * await init(options);\n * const schema = getSchema(); // entire config schema including plugins and drivers\n */\nasync function init(args) {\n  const appiumHome = args?.appiumHome ?? (await resolveAppiumHome());\n\n  adjustNodePath();\n\n  const {driverConfig, pluginConfig} = await loadExtensions(appiumHome);\n\n  const parser = getParser();\n  let throwInsteadOfExit = false;\n  /** @type {Args<T>} */\n  let preConfigArgs;\n\n  if (args) {\n    // if we have a containing package instead of running as a CLI process,\n    // that package might not appreciate us calling 'process.exit' willy-\n    // nilly, so give it the option to have us throw instead of exit\n    if (args.throwInsteadOfExit) {\n      throwInsteadOfExit = true;\n      // but remove it since it's not a real server arg per se\n      delete args.throwInsteadOfExit;\n    }\n    preConfigArgs = {...args, subcommand: args.subcommand ?? SERVER_SUBCOMMAND};\n  } else {\n    // otherwise parse from CLI\n    preConfigArgs = /** @type {Args<T>} */ (parser.parseArgs());\n  }\n\n  const configResult = await readConfigFile(preConfigArgs.configFile);\n\n  if (!_.isEmpty(configResult.errors)) {\n    throw new Error(\n      `Errors in config file ${configResult.filepath}:\\n ${\n        configResult.reason ?? configResult.errors\n      }`\n    );\n  }\n\n  // merge config and apply defaults.\n  // the order of precendece is:\n  // 1. command line args\n  // 2. config file\n  // 3. defaults from config file.\n  if (areServerCommandArgs(preConfigArgs)) {\n    const defaults = getDefaultsForSchema(false);\n\n    /** @type {ParsedArgs} */\n    const serverArgs = _.defaultsDeep(preConfigArgs, configResult.config?.server, defaults);\n\n    if (preConfigArgs.showConfig) {\n      showConfig(getNonDefaultServerArgs(preConfigArgs), configResult, defaults, serverArgs);\n      return {};\n    }\n\n    await logsinkInit(serverArgs);\n\n    if (serverArgs.logFilters) {\n      const {issues, rules} = await logFactory.loadSecureValuesPreprocessingRules(\n        serverArgs.logFilters\n      );\n      if (!_.isEmpty(issues)) {\n        throw new Error(\n          `The log filtering rules config '${serverArgs.logFilters}' has issues: ` +\n            JSON.stringify(issues, null, 2)\n        );\n      }\n      if (_.isEmpty(rules)) {\n        logger.warn(\n          `Found no log filtering rules in '${serverArgs.logFilters}'. Is that expected?`\n        );\n      } else {\n        logger.info(\n          `Loaded ${util.pluralize('filtering rule', rules.length, true)} from '${\n            serverArgs.logFilters\n          }'`\n        );\n      }\n    }\n\n    const appiumDriver = new AppiumDriver(serverArgs);\n    // set the config on the umbrella driver so it can match drivers to caps\n    appiumDriver.driverConfig = driverConfig;\n    await preflightChecks(serverArgs, throwInsteadOfExit);\n\n    return /** @type {ServerInitResult} */ ({\n      appiumDriver,\n      parsedArgs: serverArgs,\n      driverConfig,\n      pluginConfig,\n    });\n  } else {\n    const extensionCommandArgs = /** @type {Args<import('appium/types').WithExtSubcommand>} */ (\n      preConfigArgs\n    );\n    // if the user has requested the 'driver' CLI, don't run the normal server,\n    // but instead pass control to the driver CLI\n    if (preConfigArgs.subcommand === DRIVER_TYPE) {\n      await runExtensionCommand(extensionCommandArgs, driverConfig);\n      return {};\n    }\n    if (preConfigArgs.subcommand === PLUGIN_TYPE) {\n      await runExtensionCommand(extensionCommandArgs, pluginConfig);\n      return {};\n    }\n    /* istanbul ignore next */\n    return {}; // should never happen\n  }\n}\n\n/**\n * Initializes Appium's config.  Starts server if appropriate and resolves the\n * server instance if so; otherwise resolves w/ `undefined`.\n * @template [T=WithServerSubcommand]\n * @param {Args<T>} [args] - Arguments from CLI or otherwise\n * @returns {Promise<import('@appium/types').AppiumServer|undefined>}\n */\nasync function main(args) {\n  const {appiumDriver, parsedArgs, pluginConfig, driverConfig} = /** @type {ServerInitResult} */ (\n    await init(args)\n  );\n\n  if (!appiumDriver || !parsedArgs || !pluginConfig || !driverConfig) {\n    // if this branch is taken, we've run a different subcommand, so there's nothing\n    // left to do here.\n    return;\n  }\n\n  const pluginClasses = getActivePlugins(pluginConfig, parsedArgs.usePlugins);\n  // set the active plugins on the umbrella driver so it can use them for commands\n  appiumDriver.pluginClasses = pluginClasses;\n\n  await logStartupInfo(parsedArgs);\n  let routeConfiguringFunction = makeRouter(appiumDriver);\n\n  const driverClasses = getActiveDrivers(driverConfig, parsedArgs.useDrivers);\n  const serverUpdaters = getServerUpdaters(driverClasses, pluginClasses);\n  const extraMethodMap = getExtraMethodMap(driverClasses, pluginClasses);\n\n  /** @type {import('@appium/base-driver').ServerOpts} */\n  const serverOpts = {\n    routeConfiguringFunction,\n    port: parsedArgs.port,\n    hostname: parsedArgs.address,\n    allowCors: parsedArgs.allowCors,\n    basePath: parsedArgs.basePath,\n    serverUpdaters,\n    extraMethodMap,\n    cliArgs: parsedArgs,\n  };\n  if (parsedArgs.keepAliveTimeout) {\n    serverOpts.keepAliveTimeout = parsedArgs.keepAliveTimeout * 1000;\n  }\n  let server;\n  try {\n    server = await baseServer(serverOpts);\n  } catch (err) {\n    logger.error(\n      `Could not configure Appium server. It's possible that a driver or plugin tried ` +\n        `to update the server and failed. Original error: ${err.message}`\n    );\n    logger.debug(err.stack);\n    return process.exit(1);\n  }\n\n  if (parsedArgs.allowCors) {\n    logger.warn(\n      'You have enabled CORS requests from any host. Be careful not ' +\n        'to visit sites which could maliciously try to start Appium ' +\n        'sessions on your machine'\n    );\n  }\n  appiumDriver.server = server;\n  try {\n    // configure as node on grid, if necessary\n    // falsy values should not cause this to run\n    if (parsedArgs.nodeconfig) {\n      await registerNode(\n        parsedArgs.nodeconfig,\n        parsedArgs.address,\n        parsedArgs.port,\n        parsedArgs.basePath\n      );\n    }\n  } catch (err) {\n    await server.close();\n    throw err;\n  }\n\n  for (const signal of ['SIGINT', 'SIGTERM']) {\n    process.once(signal, async function onSignal() {\n      logger.info(`Received ${signal} - shutting down`);\n      try {\n        await appiumDriver.deleteAllSessions({\n          force: true,\n          reason: `The process has received ${signal} signal`,\n        });\n        await server.close();\n        process.exit(0);\n      } catch (e) {\n        logger.warn(e);\n        process.exit(1);\n      }\n    });\n  }\n\n  logServerPort(parsedArgs.address, parsedArgs.port);\n  driverConfig.print();\n  pluginConfig.print([...pluginClasses.values()]);\n\n  return server;\n}\n\n// NOTE: this is here for backwards compat for any scripts referencing `main.js` directly\n// (more specifically, `build/lib/main.js`)\n// the executable is now `../index.js`, so that module will typically be `require.main`.\nif (require.main === module) {\n  asyncify(main);\n}\n\n// everything below here is intended to be a public API.\nexport {readConfigFile} from './config-file';\nexport {finalizeSchema, getSchema, validate} from './schema/schema';\nexport {main, init, resolveAppiumHome};\n\n/**\n * @typedef {import('@appium/types').DriverType} DriverType\n * @typedef {import('@appium/types').PluginType} PluginType\n * @typedef {import('@appium/types').DriverClass} DriverClass\n * @typedef {import('@appium/types').PluginClass} PluginClass\n * @typedef {import('appium/types').WithServerSubcommand} WithServerSubcommand\n * @typedef {import('./extension').DriverNameMap} DriverNameMap\n * @typedef {import('./extension').PluginNameMap} PluginNameMap\n */\n\n/**\n * Literally an empty object\n * @typedef { {} } ExtCommandInitResult\n */\n\n/**\n * @typedef ServerInitData\n * @property {import('./appium').AppiumDriver} appiumDriver - The Appium driver\n * @property {import('appium/types').ParsedArgs} parsedArgs - The parsed arguments\n */\n\n/**\n * @typedef {ServerInitData & import('./extension').ExtensionConfigs} ServerInitResult\n */\n\n/**\n * @template [T=WithServerSubcommand]\n * @typedef {import('appium/types').Args<T>} Args\n */\n\n/**\n * @template [T=WithServerSubcommand]\n * @typedef {import('appium/types').ParsedArgs<T>} ParsedArgs\n */\n"],"mappings":"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"}

package/build/lib/schema/cli-transformers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-transformers.d.ts","sourceRoot":"","sources":["../../../lib/schema/cli-transformers.js"],"names":[],"mappings":";IA4DO,sCAiBJ;IAOK,uCA6BL"}
+{"version":3,"file":"cli-transformers.d.ts","sourceRoot":"","sources":["../../../lib/schema/cli-transformers.js"],"names":[],"mappings":";IA4DO,sCAiBJ;IAOK,uCA8BL"}