appium 2.0.0-beta.4 → 2.0.0-beta.42

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

@@ -0,0 +1,22 @@
+export const commandClasses: Readonly<{
+    readonly driver: typeof DriverCommand;
+    readonly plugin: typeof PluginCommand;
+}>;
+export type ExtCommand<ExtType extends import("@appium/types").ExtensionType> = ExtType extends DriverType ? Class<DriverCommand> : ExtType extends PluginType ? Class<PluginCommand> : never;
+export type ExtensionType = import('@appium/types').ExtensionType;
+export type DriverType = import('@appium/types').DriverType;
+export type PluginType = import('@appium/types').PluginType;
+export type Class<T> = import('@appium/types').Class<T>;
+import DriverCommand from "./driver-command";
+import PluginCommand from "./plugin-command";
+/**
+ * Run a subcommand of the 'appium driver' type. Each subcommand has its own set of arguments which
+ * can be represented as a JS object.
+ *
+ * @param {import('appium/types').Args<import('appium/types').WithExtSubcommand>} args - JS object where the key is the parameter name (as defined in
+ * driver-parser.js)
+ * @template {ExtensionType} ExtType
+ * @param {import('../extension/extension-config').ExtensionConfig<ExtType>} config - Extension config object
+ */
+export function runExtensionCommand<ExtType extends import("@appium/types").ExtensionType>(args: import('appium/types').Args<import('appium/types').WithExtSubcommand>, config: import("../extension/extension-config").ExtensionConfig<ExtType>): Promise<any>;
+//# sourceMappingURL=extension.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../../../lib/cli/extension.js"],"names":[],"mappings":"AAMA;;;GAKE;gFAiDW,OAAO,SAAS,UAAU,GAAG,MAAM,aAAa,CAAC,GAAG,OAAO,SAAS,UAAU,GAAG,MAAM,aAAa,CAAC,GAAG,KAAK;4BAI7G,OAAO,eAAe,EAAE,aAAa;yBACrC,OAAO,eAAe,EAAE,UAAU;yBAClC,OAAO,eAAe,EAAE,UAAU;uBAKlC,OAAO,eAAe,EAAE,KAAK,CAAC,CAAC,CAAC;;;AA1D7C;;;;;;;;GAQG;AACH,iGALW,OAAO,cAAc,EAAE,IAAI,CAAC,OAAO,cAAc,EAAE,iBAAiB,CAAC,0FAqC/E"}

package/build/lib/cli/extension.js

@@ -5,6 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.commandClasses = void 0;
 exports.runExtensionCommand = runExtensionCommand;
 
 require("source-map-support/register");
@@ -13,44 +14,57 @@ var _driverCommand = _interopRequireDefault(require("./driver-command"));
 
 var _pluginCommand = _interopRequireDefault(require("./plugin-command"));
 
-var _driverConfig = _interopRequireDefault(require("../driver-config"));
-
-var _pluginConfig = _interopRequireDefault(require("../plugin-config"));
-
-var _extensionConfig = require("../extension-config");
+var _constants = require("../constants");
 
 var _utils = require("./utils");
 
-async function runExtensionCommand(args, type) {
+const commandClasses = Object.freeze({
+  [_constants.DRIVER_TYPE]: _driverCommand.default,
+  [_constants.PLUGIN_TYPE]: _pluginCommand.default
+});
+exports.commandClasses = commandClasses;
+
+async function runExtensionCommand(args, config) {
   let jsonResult = null;
   const {
+    extensionType: type
+  } = config;
+  const extCmd = args[`${type}Command`];
+
+  if (!extCmd) {
+    throw new TypeError(`Cannot call ${type} command without a subcommand like 'install'`);
+  }
+
+  let {
     json,
-    appiumHome
+    suppressOutput
   } = args;
+  json = Boolean(json);
 
-  const logFn = msg => (0, _utils.log)(json, msg);
+  if (suppressOutput) {
+    json = true;
+  }
 
-  const ConfigClass = type === _extensionConfig.DRIVER_TYPE ? _driverConfig.default : _pluginConfig.default;
-  const CommandClass = type === _extensionConfig.DRIVER_TYPE ? _driverCommand.default : _pluginCommand.default;
-  const config = new ConfigClass(appiumHome, logFn);
+  const CommandClass = commandClasses[type];
   const cmd = new CommandClass({
     config,
     json
   });
 
   try {
-    await config.read();
     jsonResult = await cmd.execute(args);
   } catch (err) {
+    if (suppressOutput) {
+      throw err;
+    }
+
     (0, _utils.errAndQuit)(json, err);
   }
 
-  if (json) {
+  if (json && !suppressOutput) {
     console.log(JSON.stringify(jsonResult, null, _utils.JSON_SPACES));
   }
 
   return jsonResult;
-}require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/cli/parser.d.ts

@@ -0,0 +1,84 @@
+export const EXTRA_ARGS: "extraArgs";
+export type DriverType = import('@appium/types').DriverType;
+export type PluginType = import('@appium/types').PluginType;
+/**
+ * Creates a {@link ArgParser} instance; finalizes the config schema.
+ *
+ * @constructs ArgParser
+ * @param {boolean} [debug] - If `true`, throw instead of exit upon parsing error
+ * @returns {ArgParser}
+ */
+export function getParser(debug?: boolean | undefined): ArgParser;
+/**
+ * A wrapper around `argparse`
+ *
+ * - Handles instantiation, configuration, and monkeypatching of an
+ *    `ArgumentParser` instance for Appium server and its extensions
+ * - Handles error conditions, messages, and exit behavior
+ */
+export class ArgParser {
+    /**
+     * Given an object full of arguments as returned by `argparser.parse_args`,
+     * expand the ones for extensions into a nested object structure and rename
+     * keys to match the intended destination.
+     *
+     * E.g., `{'driver-foo-bar': baz}` becomes `{driver: {foo: {bar: 'baz'}}}`
+     * @param {object} args
+     * @param {string[]} [unknownArgs]
+     * @returns {object}
+     */
+    static _transformParsedArgs(args: object, unknownArgs?: string[] | undefined): object;
+    /**
+     * Patches the `exit()` method of the parser to throw an error, so we can handle it manually.
+     * @param {ArgumentParser} parser
+     */
+    static _patchExit(parser: ArgumentParser): void;
+    /**
+     *
+     * @param {import('argparse').SubParser} subParser
+     * @returns {import('./args').ArgumentDefinitions}
+     */
+    static _addServerToParser(subParser: import('argparse').SubParser): import('./args').ArgumentDefinitions;
+    /**
+     * Adds extension sub-sub-commands to `driver`/`plugin` subcommands
+     * @param {import('argparse').SubParser} subParsers
+     */
+    static _addExtensionCommandsToParser(subParsers: import('argparse').SubParser): void;
+    /**
+     * @param {boolean} [debug] - If true, throw instead of exit on error.
+     */
+    constructor(debug?: boolean | undefined);
+    /**
+     * Program name (typically `appium`)
+     * @type {string}
+     */
+    prog: string;
+    /**
+     * If `true`, throw an error on parse failure instead of printing help
+     * @type {boolean}
+     */
+    debug: boolean;
+    /**
+     * Wrapped `ArgumentParser` instance
+     * @type {ArgumentParser}
+     */
+    parser: ArgumentParser;
+    rawArgs: import("./args").ArgumentDefinitions;
+    /**
+     * @type {ArgParser['parseArgs']}
+     */
+    parse_args: ArgParser['parseArgs'];
+    /**
+     * Parse arguments from the command line.
+     *
+     * If no subcommand is passed in, this method will inject the `server` subcommand.
+     *
+     * `ArgParser.prototype.parse_args` is an alias of this method.
+     * @template [T=import('appium/types').WithServerSubcommand]
+     * @param {string[]} [args] - Array of arguments, ostensibly from `process.argv`. Gathers args from `process.argv` if not provided.
+     * @returns {import('appium/types').Args<T>} - The parsed arguments
+     */
+    parseArgs<T = import("appium/types").WithServerSubcommand>(args?: string[] | undefined): import("appium/types").Args<T>;
+}
+import { ArgumentParser } from "argparse";
+//# sourceMappingURL=parser.d.ts.map

package/build/lib/cli/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../lib/cli/parser.js"],"names":[],"mappings":"AASA,qCAAsC;yBA0QzB,OAAO,eAAe,EAAE,UAAU;yBAClC,OAAO,eAAe,EAAE,UAAU;AAjB/C;;;;;;GAMG;AACH,wDAFa,SAAS,CAMrB;AAzPD;;;;;;GAMG;AACH;IAqGE;;;;;;;;;OASG;IACH,kCAJW,MAAM,uCAEJ,MAAM,CAmBlB;IAED;;;OAGG;IACH,0BAFW,cAAc,QASxB;IAED;;;;OAIG;IACH,qCAHW,OAAO,UAAU,EAAE,SAAS,GAC1B,OAAO,QAAQ,EAAE,mBAAmB,CAkBhD;IAED;;;OAGG;IACH,iDAFW,OAAO,UAAU,EAAE,SAAS,QA4DtC;IAnOD;;OAEG;IACH,yCAmDC;IAxCC;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,OAFU,OAAO,CAEC;IAElB;;;OAGG;IACH,QAFU,cAAc,CAEJ;IAcpB,8CAAyB;IAMzB;;OAEG;IACH,YAFU,SAAS,CAAC,WAAW,CAAC,CAEA;IAGlC;;;;;;;;;OASG;IACH,wHAgCC;CAkIF"}

package/build/lib/cli/parser.js

@@ -5,130 +5,200 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.EXTRA_ARGS = exports.ArgParser = void 0;
 exports.getParser = getParser;
-exports.getDefaultServerArgs = getDefaultServerArgs;
-exports.default = void 0;
 
 require("source-map-support/register");
 
-var _path = _interopRequireDefault(require("path"));
+var _support = require("@appium/support");
+
+var _argparse = require("argparse");
 
 var _lodash = _interopRequireDefault(require("lodash"));
 
-var _argparse = require("argparse");
+var _path = _interopRequireDefault(require("path"));
+
+var _constants = require("../constants");
+
+var _schema = require("../schema");
+
+var _config = require("../config");
 
 var _args = require("./args");
 
-var _extensionConfig = require("../extension-config");
-
-var _utils = require("../utils");
-
-function getParser(debug = false) {
-  const parser = new _argparse.ArgumentParser({
-    version: require(_path.default.resolve(_utils.rootDir, 'package.json')).version,
-    addHelp: true,
-    description: 'A webdriver-compatible server for use with native and hybrid iOS and Android applications.',
-    prog: process.argv[1] ? _path.default.basename(process.argv[1]) : 'appium',
-    debug
-  });
-  const subParsers = parser.addSubparsers({
-    dest: 'subcommand',
-    debug
-  });
-  const serverArgs = addServerToParser(_args.sharedArgs, subParsers, debug);
-  parser.rawArgs = serverArgs;
-  addExtensionsToParser(_args.sharedArgs, subParsers, debug);
-  parser._parseArgs = parser.parseArgs;
-
-  parser.parseArgs = function (args, namespace) {
-    if (_lodash.default.isUndefined(args)) {
-      args = [...process.argv.slice(2)];
-    }
+const EXTRA_ARGS = 'extraArgs';
+exports.EXTRA_ARGS = EXTRA_ARGS;
+const NON_SERVER_ARGS = Object.freeze(new Set([_constants.DRIVER_TYPE, _constants.PLUGIN_TYPE, _constants.SERVER_SUBCOMMAND, '-h', '--help', '-v', '--version']));
+
+const version = _support.fs.readPackageJsonFrom(_config.rootDir).version;
+
+class ArgParser {
+  constructor(debug = false) {
+    const prog = process.argv[1] ? _path.default.basename(process.argv[1]) : 'appium';
+    const parser = new _argparse.ArgumentParser({
+      add_help: true,
+      description: 'A webdriver-compatible server that facilitates automation of web, mobile, and other types of apps across various platforms.',
+      prog
+    });
+
+    ArgParser._patchExit(parser);
 
-    if (!_lodash.default.includes([_extensionConfig.DRIVER_TYPE, _extensionConfig.PLUGIN_TYPE, 'server', '-h'], args[0])) {
-      args.splice(0, 0, 'server');
+    this.prog = prog;
+    this.debug = debug;
+    this.parser = parser;
+    parser.add_argument('-v', '--version', {
+      action: 'version',
+      version
+    });
+    const subParsers = parser.add_subparsers({
+      dest: 'subcommand'
+    });
+
+    const serverArgs = ArgParser._addServerToParser(subParsers);
+
+    this.rawArgs = serverArgs;
+
+    ArgParser._addExtensionCommandsToParser(subParsers);
+
+    this.parse_args = this.parseArgs;
+  }
+
+  parseArgs(args = process.argv.slice(2)) {
+    if (!NON_SERVER_ARGS.has(args[0])) {
+      args.unshift(_constants.SERVER_SUBCOMMAND);
     }
 
-    return this._parseArgs(args, namespace);
-  }.bind(parser);
+    try {
+      const parsed = this.parser.parse_known_args(args);
+      const [knownArgs, unknownArgs] = parsed;
 
-  return parser;
-}
+      if (unknownArgs !== null && unknownArgs !== void 0 && unknownArgs.length && (knownArgs.driverCommand === 'run' || knownArgs.pluginCommand === 'run')) {
+        return ArgParser._transformParsedArgs(knownArgs, unknownArgs);
+      } else if (unknownArgs !== null && unknownArgs !== void 0 && unknownArgs.length) {
+        throw new Error(`[ERROR] Unrecognized arguments: ${unknownArgs.join(' ')}`);
+      }
 
-function addServerToParser(sharedArgs, subParsers, debug) {
-  const serverParser = subParsers.addParser('server', {
-    addHelp: true,
-    help: 'Run an Appium server',
-    debug
-  });
+      return ArgParser._transformParsedArgs(knownArgs);
+    } catch (err) {
+      if (this.debug) {
+        throw err;
+      }
 
-  for (const [flags, opts] of [...sharedArgs, ..._args.serverArgs]) {
-    serverParser.addArgument([...flags], { ...opts
-    });
+      {
+        console.error();
+        console.error(err.message);
+        process.exit(1);
+      }
+    }
   }
 
-  return _args.serverArgs;
-}
+  static _transformParsedArgs(args, unknownArgs = []) {
+    const result = _lodash.default.reduce(args, (unpacked, value, key) => {
+      if (!_lodash.default.isUndefined(value) && (0, _schema.hasArgSpec)(key)) {
+        const {
+          dest
+        } = (0, _schema.getArgSpec)(key);
 
-function getDefaultServerArgs() {
-  let defaults = {};
+        _lodash.default.set(unpacked, dest, value);
+      } else {
+        unpacked[key] = value;
+      }
 
-  for (let [, arg] of _args.serverArgs) {
-    defaults[arg.dest] = arg.defaultValue;
+      return unpacked;
+    }, {});
+
+    result[EXTRA_ARGS] = unknownArgs;
+    return result;
   }
 
-  return defaults;
-}
+  static _patchExit(parser) {
+    parser.exit = (code, msg) => {
+      if (code) {
+        throw new Error(msg);
+      }
 
-function addExtensionsToParser(sharedArgs, subParsers, debug) {
-  for (const type of [_extensionConfig.DRIVER_TYPE, _extensionConfig.PLUGIN_TYPE]) {
-    const extParser = subParsers.addParser(type, {
-      addHelp: true,
-      help: `Access the ${type} management CLI commands`,
-      debug
-    });
-    const extSubParsers = extParser.addSubparsers({
-      dest: `${type}Command`,
-      debug
+      process.exit();
+    };
+  }
+
+  static _addServerToParser(subParser) {
+    const serverParser = subParser.add_parser('server', {
+      add_help: true,
+      help: 'Run an Appium server'
     });
-    const parserSpecs = [{
-      command: 'list',
-      args: _args.extensionArgs[type].list,
-      help: `List available and installed ${type}s`
-    }, {
-      command: 'install',
-      args: _args.extensionArgs[type].install,
-      help: `Install a ${type}`
-    }, {
-      command: 'uninstall',
-      args: _args.extensionArgs[type].uninstall,
-      help: `Uninstall a ${type}`
-    }, {
-      command: 'update',
-      args: _args.extensionArgs[type].update,
-      help: `Update installed ${type}s to the latest version`
-    }];
-
-    for (const {
-      command,
-      args,
-      help
-    } of parserSpecs) {
-      const parser = extSubParsers.addParser(command, {
-        help,
-        debug
+
+    ArgParser._patchExit(serverParser);
+
+    const serverArgs = (0, _args.getServerArgs)();
+
+    for (const [flagsOrNames, opts] of serverArgs) {
+      serverParser.add_argument(...flagsOrNames, { ...opts
       });
+    }
+
+    return serverArgs;
+  }
+
+  static _addExtensionCommandsToParser(subParsers) {
+    for (const type of [_constants.DRIVER_TYPE, _constants.PLUGIN_TYPE]) {
+      const extParser = subParsers.add_parser(type, {
+        add_help: true,
+        help: `Access the ${type} management CLI commands`
+      });
+
+      ArgParser._patchExit(extParser);
 
-      for (const [flags, opts] of [...sharedArgs, ...args]) {
-        parser.addArgument([...flags], { ...opts
+      const extSubParsers = extParser.add_subparsers({
+        dest: `${type}Command`
+      });
+      const extensionArgs = (0, _args.getExtensionArgs)();
+      const parserSpecs = [{
+        command: 'list',
+        args: extensionArgs[type].list,
+        help: `List available and installed ${type}s`
+      }, {
+        command: 'install',
+        args: extensionArgs[type].install,
+        help: `Install a ${type}`
+      }, {
+        command: 'uninstall',
+        args: extensionArgs[type].uninstall,
+        help: `Uninstall a ${type}`
+      }, {
+        command: 'update',
+        args: extensionArgs[type].update,
+        help: `Update installed ${type}s to the latest version`
+      }, {
+        command: 'run',
+        args: extensionArgs[type].run,
+        help: `Run a script (defined inside the ${type}'s package.json under the ` + `“scripts” field inside the “appium” field) from an installed ${type}`
+      }];
+
+      for (const {
+        command,
+        args,
+        help
+      } of parserSpecs) {
+        const parser = extSubParsers.add_parser(command, {
+          help
         });
+
+        ArgParser._patchExit(parser);
+
+        for (const [flagsOrNames, opts] of args) {
+          parser.add_argument(...flagsOrNames, { ...opts
+          });
+        }
       }
     }
   }
-}
 
-var _default = getParser;
-exports.default = _default;require('source-map-support').install();
+}
 
+exports.ArgParser = ArgParser;
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/cli/parser.js"],"names":["getParser","debug","parser","ArgumentParser","version","require","path","resolve","rootDir","addHelp","description","prog","process","argv","basename","subParsers","addSubparsers","dest","serverArgs","addServerToParser","sharedArgs","rawArgs","addExtensionsToParser","_parseArgs","parseArgs","args","namespace","_","isUndefined","slice","includes","DRIVER_TYPE","PLUGIN_TYPE","splice","bind","serverParser","addParser","help","flags","opts","addArgument","getDefaultServerArgs","defaults","arg","defaultValue","type","extParser","extSubParsers","parserSpecs","command","extensionArgs","list","install","uninstall","update"],"mappings":"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","sourcesContent":["import path from 'path';\nimport _ from 'lodash';\nimport { ArgumentParser } from 'argparse';\nimport { sharedArgs, serverArgs, extensionArgs } from './args';\nimport { DRIVER_TYPE, PLUGIN_TYPE } from '../extension-config';\nimport { rootDir } from '../utils';\n\nfunction getParser (debug = false) {\n  const parser = new ArgumentParser({\n    version: require(path.resolve(rootDir, 'package.json')).version,\n    addHelp: true,\n    description: 'A webdriver-compatible server for use with native and hybrid iOS and Android applications.',\n    prog: process.argv[1] ? path.basename(process.argv[1]) : 'appium',\n    debug\n  });\n  const subParsers = parser.addSubparsers({dest: 'subcommand', debug});\n\n  // add the 'server' subcommand, and store the raw arguments on the parser\n  // object as a way for other parts of the code to work with the arguments\n  // conceptually rather than just through argparse\n  const serverArgs = addServerToParser(sharedArgs, subParsers, debug);\n  parser.rawArgs = serverArgs;\n\n  // add the 'driver' and 'plugin' subcommands\n  addExtensionsToParser(sharedArgs, subParsers, debug);\n\n  // modify the parseArgs function to insert the 'server' subcommand if the\n  // user hasn't specified a subcommand or the global help command\n  parser._parseArgs = parser.parseArgs;\n  parser.parseArgs = function (args, namespace) {\n    if (_.isUndefined(args)) {\n      args = [...process.argv.slice(2)];\n    }\n    if (!_.includes([DRIVER_TYPE, PLUGIN_TYPE, 'server', '-h'], args[0])) {\n      args.splice(0, 0, 'server');\n    }\n    return this._parseArgs(args, namespace);\n  }.bind(parser);\n  return parser;\n}\n\nfunction addServerToParser (sharedArgs, subParsers, debug) {\n  const serverParser = subParsers.addParser('server', {\n    addHelp: true,\n    help: 'Run an Appium server',\n    debug\n  });\n\n  for (const [flags, opts] of [...sharedArgs, ...serverArgs]) {\n    // addArgument mutates arguments so make copies\n    serverParser.addArgument([...flags], {...opts});\n  }\n\n  return serverArgs;\n}\n\nfunction getDefaultServerArgs () {\n  let defaults = {};\n  for (let [, arg] of serverArgs) {\n    defaults[arg.dest] = arg.defaultValue;\n  }\n  return defaults;\n}\n\nfunction addExtensionsToParser (sharedArgs, subParsers, debug) {\n  for (const type of [DRIVER_TYPE, PLUGIN_TYPE]) {\n    const extParser = subParsers.addParser(type, {\n      addHelp: true,\n      help: `Access the ${type} management CLI commands`,\n      debug\n    });\n    const extSubParsers = extParser.addSubparsers({\n      dest: `${type}Command`,\n      debug\n    });\n    const parserSpecs = [\n      {command: 'list', args: extensionArgs[type].list,\n       help: `List available and installed ${type}s`},\n      {command: 'install', args: extensionArgs[type].install,\n       help: `Install a ${type}`},\n      {command: 'uninstall', args: extensionArgs[type].uninstall,\n       help: `Uninstall a ${type}`},\n      {command: 'update', args: extensionArgs[type].update,\n       help: `Update installed ${type}s to the latest version`},\n    ];\n\n    for (const {command, args, help} of parserSpecs) {\n      const parser = extSubParsers.addParser(command, {help, debug});\n      for (const [flags, opts] of [...sharedArgs, ...args]) {\n        // addArgument mutates params so make sure to send in copies instead\n        parser.addArgument([...flags], {...opts});\n      }\n    }\n  }\n}\n\nexport default getParser;\nexport { getParser, getDefaultServerArgs };\n"],"file":"lib/cli/parser.js","sourceRoot":"../../.."}
+function getParser(debug) {
+  (0, _schema.finalizeSchema)();
+  return new ArgParser(debug);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["EXTRA_ARGS","NON_SERVER_ARGS","Object","freeze","Set","DRIVER_TYPE","PLUGIN_TYPE","SERVER_SUBCOMMAND","version","fs","readPackageJsonFrom","rootDir","ArgParser","constructor","debug","prog","process","argv","path","basename","parser","ArgumentParser","add_help","description","_patchExit","add_argument","action","subParsers","add_subparsers","dest","serverArgs","_addServerToParser","rawArgs","_addExtensionCommandsToParser","parse_args","parseArgs","args","slice","has","unshift","parsed","parse_known_args","knownArgs","unknownArgs","length","driverCommand","pluginCommand","_transformParsedArgs","Error","join","err","console","error","message","exit","result","_","reduce","unpacked","value","key","isUndefined","hasArgSpec","getArgSpec","set","code","msg","subParser","serverParser","add_parser","help","getServerArgs","flagsOrNames","opts","type","extParser","extSubParsers","extensionArgs","getExtensionArgs","parserSpecs","command","list","install","uninstall","update","run","getParser","finalizeSchema"],"sources":["../../../lib/cli/parser.js"],"sourcesContent":["import {fs} from '@appium/support';\nimport {ArgumentParser} from 'argparse';\nimport _ from 'lodash';\nimport path from 'path';\nimport {DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND} from '../constants';\nimport {finalizeSchema, getArgSpec, hasArgSpec} from '../schema';\nimport {rootDir} from '../config';\nimport {getExtensionArgs, getServerArgs} from './args';\n\nexport const EXTRA_ARGS = 'extraArgs';\n\n/**\n * If the parsed args do not contain any of these values, then we\n * will automatially inject the `server` subcommand.\n */\nconst NON_SERVER_ARGS = Object.freeze(\n  new Set([DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND, '-h', '--help', '-v', '--version'])\n);\n\nconst version = fs.readPackageJsonFrom(rootDir).version;\n\n/**\n * A wrapper around `argparse`\n *\n * - Handles instantiation, configuration, and monkeypatching of an\n *    `ArgumentParser` instance for Appium server and its extensions\n * - Handles error conditions, messages, and exit behavior\n */\nclass ArgParser {\n  /**\n   * @param {boolean} [debug] - If true, throw instead of exit on error.\n   */\n  constructor(debug = false) {\n    const prog = process.argv[1] ? path.basename(process.argv[1]) : 'appium';\n    const parser = new ArgumentParser({\n      add_help: true,\n      description:\n        'A webdriver-compatible server that facilitates automation of web, mobile, and other types of apps across various platforms.',\n      prog,\n    });\n\n    ArgParser._patchExit(parser);\n\n    /**\n     * Program name (typically `appium`)\n     * @type {string}\n     */\n    this.prog = prog;\n\n    /**\n     * If `true`, throw an error on parse failure instead of printing help\n     * @type {boolean}\n     */\n    this.debug = debug;\n\n    /**\n     * Wrapped `ArgumentParser` instance\n     * @type {ArgumentParser}\n     */\n    this.parser = parser;\n\n    parser.add_argument('-v', '--version', {\n      action: 'version',\n      version,\n    });\n\n    const subParsers = parser.add_subparsers({dest: 'subcommand'});\n\n    // add the 'server' subcommand, and store the raw arguments on the parser\n    // object as a way for other parts of the code to work with the arguments\n    // conceptually rather than just through argparse\n    const serverArgs = ArgParser._addServerToParser(subParsers);\n\n    this.rawArgs = serverArgs;\n\n    // add the 'driver' and 'plugin' subcommands\n    ArgParser._addExtensionCommandsToParser(subParsers);\n\n    // backwards compatibility / drop-in wrapper\n    /**\n     * @type {ArgParser['parseArgs']}\n     */\n    this.parse_args = this.parseArgs;\n  }\n\n  /**\n   * Parse arguments from the command line.\n   *\n   * If no subcommand is passed in, this method will inject the `server` subcommand.\n   *\n   * `ArgParser.prototype.parse_args` is an alias of this method.\n   * @template [T=import('appium/types').WithServerSubcommand]\n   * @param {string[]} [args] - Array of arguments, ostensibly from `process.argv`. Gathers args from `process.argv` if not provided.\n   * @returns {import('appium/types').Args<T>} - The parsed arguments\n   */\n  parseArgs(args = process.argv.slice(2)) {\n    if (!NON_SERVER_ARGS.has(args[0])) {\n      args.unshift(SERVER_SUBCOMMAND);\n    }\n\n    try {\n      const parsed = this.parser.parse_known_args(args);\n      const [knownArgs, unknownArgs] = parsed;\n      if (\n        unknownArgs?.length &&\n        (knownArgs.driverCommand === 'run' || knownArgs.pluginCommand === 'run')\n      ) {\n        return ArgParser._transformParsedArgs(knownArgs, unknownArgs);\n      } else if (unknownArgs?.length) {\n        throw new Error(`[ERROR] Unrecognized arguments: ${unknownArgs.join(' ')}`);\n      }\n      return ArgParser._transformParsedArgs(knownArgs);\n    } catch (err) {\n      if (this.debug) {\n        throw err;\n      }\n      // this isn't tested via unit tests (we use `debug: true`) so may escape coverage.\n\n      /* istanbul ignore next */\n      {\n        // eslint-disable-next-line no-console\n        console.error(); // need an extra space since argparse prints usage.\n        // eslint-disable-next-line no-console\n        console.error(err.message);\n        process.exit(1);\n      }\n    }\n  }\n\n  /**\n   * Given an object full of arguments as returned by `argparser.parse_args`,\n   * expand the ones for extensions into a nested object structure and rename\n   * keys to match the intended destination.\n   *\n   * E.g., `{'driver-foo-bar': baz}` becomes `{driver: {foo: {bar: 'baz'}}}`\n   * @param {object} args\n   * @param {string[]} [unknownArgs]\n   * @returns {object}\n   */\n  static _transformParsedArgs(args, unknownArgs = []) {\n    const result = _.reduce(\n      args,\n      (unpacked, value, key) => {\n        if (!_.isUndefined(value) && hasArgSpec(key)) {\n          const {dest} = /** @type {import('../schema/arg-spec').ArgSpec} */ (getArgSpec(key));\n          _.set(unpacked, dest, value);\n        } else {\n          // this could be anything that _isn't_ a server arg\n          unpacked[key] = value;\n        }\n        return unpacked;\n      },\n      {}\n    );\n    result[EXTRA_ARGS] = unknownArgs;\n    return result;\n  }\n\n  /**\n   * Patches the `exit()` method of the parser to throw an error, so we can handle it manually.\n   * @param {ArgumentParser} parser\n   */\n  static _patchExit(parser) {\n    parser.exit = (code, msg) => {\n      if (code) {\n        throw new Error(msg);\n      }\n      process.exit();\n    };\n  }\n\n  /**\n   *\n   * @param {import('argparse').SubParser} subParser\n   * @returns {import('./args').ArgumentDefinitions}\n   */\n  static _addServerToParser(subParser) {\n    const serverParser = subParser.add_parser('server', {\n      add_help: true,\n      help: 'Run an Appium server',\n    });\n\n    ArgParser._patchExit(serverParser);\n\n    const serverArgs = getServerArgs();\n    for (const [flagsOrNames, opts] of serverArgs) {\n      // TS doesn't like the spread operator here.\n      // @ts-ignore\n      serverParser.add_argument(...flagsOrNames, {...opts});\n    }\n\n    return serverArgs;\n  }\n\n  /**\n   * Adds extension sub-sub-commands to `driver`/`plugin` subcommands\n   * @param {import('argparse').SubParser} subParsers\n   */\n  static _addExtensionCommandsToParser(subParsers) {\n    for (const type of /** @type {[DriverType, PluginType]} */ ([DRIVER_TYPE, PLUGIN_TYPE])) {\n      const extParser = subParsers.add_parser(type, {\n        add_help: true,\n        help: `Access the ${type} management CLI commands`,\n      });\n\n      ArgParser._patchExit(extParser);\n\n      const extSubParsers = extParser.add_subparsers({\n        dest: `${type}Command`,\n      });\n      const extensionArgs = getExtensionArgs();\n      /**\n       * @type { {command: import('appium/types').CliExtensionSubcommand, args: import('./args').ArgumentDefinitions, help: string}[] }\n       */\n      const parserSpecs = [\n        {\n          command: 'list',\n          args: extensionArgs[type].list,\n          help: `List available and installed ${type}s`,\n        },\n        {\n          command: 'install',\n          args: extensionArgs[type].install,\n          help: `Install a ${type}`,\n        },\n        {\n          command: 'uninstall',\n          args: extensionArgs[type].uninstall,\n          help: `Uninstall a ${type}`,\n        },\n        {\n          command: 'update',\n          args: extensionArgs[type].update,\n          help: `Update installed ${type}s to the latest version`,\n        },\n        {\n          command: 'run',\n          args: extensionArgs[type].run,\n          help:\n            `Run a script (defined inside the ${type}'s package.json under the ` +\n            `“scripts” field inside the “appium” field) from an installed ${type}`,\n        },\n      ];\n\n      for (const {command, args, help} of parserSpecs) {\n        const parser = extSubParsers.add_parser(command, {help});\n\n        ArgParser._patchExit(parser);\n\n        for (const [flagsOrNames, opts] of args) {\n          // add_argument mutates params so make sure to send in copies instead\n          // @ts-ignore\n          parser.add_argument(...flagsOrNames, {...opts});\n        }\n      }\n    }\n  }\n}\n\n/**\n * Creates a {@link ArgParser} instance; finalizes the config schema.\n *\n * @constructs ArgParser\n * @param {boolean} [debug] - If `true`, throw instead of exit upon parsing error\n * @returns {ArgParser}\n */\nfunction getParser(debug) {\n  finalizeSchema();\n\n  return new ArgParser(debug);\n}\n\nexport {getParser, ArgParser};\n\n/**\n * @typedef {import('@appium/types').DriverType} DriverType\n * @typedef {import('@appium/types').PluginType} PluginType\n */\n"],"mappings":"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"}

package/build/lib/cli/plugin-command.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @extends {ExtensionCommand<PluginType>}
+ */
+export default class PluginCommand extends ExtensionCommand<"plugin"> {
+    /**
+     *
+     * @param {import('./extension-command').ExtensionCommandOptions<PluginType>} opts
+     */
+    constructor({ config, json }: import('./extension-command').ExtensionCommandOptions<PluginType>);
+    install({ plugin, installType, packageName }: {
+        plugin: any;
+        installType: any;
+        packageName: any;
+    }): Promise<import("./extension-command").ExtRecord<"plugin">>;
+    uninstall({ plugin }: {
+        plugin: any;
+    }): Promise<import("./extension-command").ExtRecord<"plugin">>;
+    update({ plugin, unsafe }: {
+        plugin: any;
+        unsafe: any;
+    }): Promise<import("./extension-command").ExtensionUpdateResult>;
+    run({ plugin, scriptName, extraArgs }: {
+        plugin: any;
+        scriptName: any;
+        extraArgs: any;
+    }): Promise<import("./extension-command").RunOutput>;
+    getPostInstallText({ extName, extData }: {
+        extName: any;
+        extData: any;
+    }): string;
+}
+export type PluginType = import('@appium/types').PluginType;
+import ExtensionCommand from "./extension-command";
+//# sourceMappingURL=plugin-command.d.ts.map

package/build/lib/cli/plugin-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-command.d.ts","sourceRoot":"","sources":["../../../lib/cli/plugin-command.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IACE;;;OAGG;IACH,8BAFW,OAAO,qBAAqB,EAAE,uBAAuB,CAAC,UAAU,CAAC,EAK3E;IAED;;;;mEAMC;IAED;;mEAEC;IAED;;;qEAEC;IAED;;;;yDAEC;IAED;;;eAEC;CAyBF;yBAGY,OAAO,eAAe,EAAE,UAAU"}