appium 2.0.0-beta.3 → 2.0.0-beta.34

package/build/lib/main.js

@@ -1,14 +1,38 @@
 #!/usr/bin/env node
 "use strict";
 
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
-
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "finalizeSchema", {
+  enumerable: true,
+  get: function () {
+    return _schema.finalizeSchema;
+  }
+});
+Object.defineProperty(exports, "getSchema", {
+  enumerable: true,
+  get: function () {
+    return _schema.getSchema;
+  }
+});
+exports.init = init;
 exports.main = main;
+Object.defineProperty(exports, "readConfigFile", {
+  enumerable: true,
+  get: function () {
+    return _configFile.readConfigFile;
+  }
+});
+exports.resolveAppiumHome = void 0;
+Object.defineProperty(exports, "validate", {
+  enumerable: true,
+  get: function () {
+    return _schema.validate;
+  }
+});
 
 require("source-map-support/register");
 
@@ -16,41 +40,40 @@ var _logsink = require("./logsink");
 
 var _logger = _interopRequireDefault(require("./logger"));
 
-var _lodash = _interopRequireDefault(require("lodash"));
+var _baseDriver = require("@appium/base-driver");
 
-var _appiumBaseDriver = require("appium-base-driver");
+var _support = require("@appium/support");
 
 var _asyncbox = require("asyncbox");
 
-var _parser = _interopRequireWildcard(require("./cli/parser"));
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _appium = require("./appium");
 
-var _args = require("./cli/args");
+var _extension = require("./cli/extension");
 
-var _appiumSupport = require("appium-support");
+var _parser = require("./cli/parser");
 
 var _config = require("./config");
 
-var _driverConfig = _interopRequireDefault(require("./driver-config"));
+var _configFile = require("./config-file");
 
-var _pluginConfig = _interopRequireDefault(require("./plugin-config"));
+var _extension2 = require("./extension");
 
-var _extensionConfig = require("./extension-config");
-
-var _extension = require("./cli/extension");
-
-var _appium = require("./appium");
+var _constants = require("./constants");
 
 var _gridRegister = _interopRequireDefault(require("./grid-register"));
 
+var _schema = require("./schema/schema");
+
 var _utils = require("./utils");
 
-async function preflightChecks({
-  parser,
-  args,
-  driverConfig,
-  pluginConfig,
-  throwInsteadOfExit = false
-}) {
+const {
+  resolveAppiumHome
+} = _support.env;
+exports.resolveAppiumHome = resolveAppiumHome;
+
+async function preflightChecks(args, throwInsteadOfExit = false) {
   try {
     (0, _config.checkNodeOk)();
 
@@ -58,15 +81,13 @@ async function preflightChecks({
       require('longjohn').async_trace_limit = -1;
     }
 
-    if (args.showConfig) {
-      await (0, _config.showConfig)();
+    if (args.showBuildInfo) {
+      await (0, _config.showBuildInfo)();
       process.exit(0);
     }
 
     (0, _config.warnNodeDeprecations)();
-    (0, _config.validateServerArgs)(parser, args);
-    await driverConfig.read();
-    await pluginConfig.read();
+    (0, _schema.validate)(args);
 
     if (args.tmpDir) {
       await (0, _config.validateTmpDir)(args.tmpDir);
@@ -85,16 +106,16 @@ async function preflightChecks({
 function logNonDefaultArgsWarning(args) {
   _logger.default.info('Non-default server args:');
 
-  (0, _utils.inspectObject)(args);
+  (0, _utils.inspect)(args);
 }
 
 function logDefaultCapabilitiesWarning(caps) {
   _logger.default.info('Default capabilities, which will be added to each request ' + 'unless overridden by desired capabilities:');
 
-  (0, _utils.inspectObject)(caps);
+  (0, _utils.inspect)(caps);
 }
 
-async function logStartupInfo(parser, args) {
+async function logStartupInfo(args) {
   let welcome = `Welcome to Appium v${_config.APPIUM_VER}`;
   let appiumRev = await (0, _config.getGitRev)();
 
@@ -104,7 +125,7 @@ async function logStartupInfo(parser, args) {
 
   _logger.default.info(welcome);
 
-  let showArgs = (0, _config.getNonDefaultArgs)(parser, args);
+  let showArgs = (0, _config.getNonDefaultServerArgs)(args);
 
   if (_lodash.default.size(showArgs)) {
     logNonDefaultArgsWarning(showArgs);
@@ -121,88 +142,168 @@ function logServerPort(address, port) {
   _logger.default.info(logMessage);
 }
 
-async function main(args = null) {
-  let parser = (0, _parser.default)();
+function getServerUpdaters(driverClasses, pluginClasses) {
+  return _lodash.default.compact(_lodash.default.map([...driverClasses, ...pluginClasses], 'updateServer'));
+}
+
+function getExtraMethodMap(driverClasses, pluginClasses) {
+  return [...driverClasses, ...pluginClasses].reduce((map, klass) => {
+    var _klass$newMethodMap;
+
+    return { ...map,
+      ...((_klass$newMethodMap = klass.newMethodMap) !== null && _klass$newMethodMap !== void 0 ? _klass$newMethodMap : {})
+    };
+  }, {});
+}
+
+function areServerCommandArgs(args) {
+  return args.subcommand === _constants.SERVER_SUBCOMMAND;
+}
+
+async function init(args) {
+  var _args$appiumHome;
+
+  const appiumHome = (_args$appiumHome = args === null || args === void 0 ? void 0 : args.appiumHome) !== null && _args$appiumHome !== void 0 ? _args$appiumHome : await resolveAppiumHome();
+  const {
+    driverConfig,
+    pluginConfig
+  } = await (0, _extension2.loadExtensions)(appiumHome);
+  const parser = (0, _parser.getParser)();
   let throwInsteadOfExit = false;
+  let preConfigArgs;
 
   if (args) {
-    args = Object.assign({}, (0, _parser.getDefaultServerArgs)(), args);
+    var _args$subcommand;
 
     if (args.throwInsteadOfExit) {
       throwInsteadOfExit = true;
       delete args.throwInsteadOfExit;
     }
+
+    preConfigArgs = { ...args,
+      subcommand: (_args$subcommand = args.subcommand) !== null && _args$subcommand !== void 0 ? _args$subcommand : _constants.SERVER_SUBCOMMAND
+    };
   } else {
-    args = parser.parseArgs();
+    preConfigArgs = parser.parseArgs();
   }
 
-  await (0, _logsink.init)(args);
+  const configResult = await (0, _configFile.readConfigFile)(preConfigArgs.configFile);
+
+  if (!_lodash.default.isEmpty(configResult.errors)) {
+    var _configResult$reason;
 
-  if (args.subcommand === _extensionConfig.DRIVER_TYPE || args.subcommand === _extensionConfig.PLUGIN_TYPE) {
-    await (0, _extension.runExtensionCommand)(args, args.subcommand);
-    process.exit();
+    throw new Error(`Errors in config file ${configResult.filepath}:\n ${(_configResult$reason = configResult.reason) !== null && _configResult$reason !== void 0 ? _configResult$reason : configResult.errors}`);
   }
 
-  if (args.logFilters) {
-    const {
-      issues,
-      rules
-    } = await _appiumSupport.logger.loadSecureValuesPreprocessingRules(args.logFilters);
+  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 {
+    var _configResult$config;
+
+    const defaults = (0, _schema.getDefaultsForSchema)(false);
 
-    if (!_lodash.default.isEmpty(issues)) {
-      throw new Error(`The log filtering rules config '${args.logFilters}' has issues: ` + JSON.stringify(issues, null, 2));
+    const serverArgs = _lodash.default.defaultsDeep(preConfigArgs, (_configResult$config = configResult.config) === null || _configResult$config === void 0 ? void 0 : _configResult$config.server, defaults);
+
+    if (preConfigArgs.showConfig) {
+      (0, _config.showConfig)((0, _config.getNonDefaultServerArgs)(preConfigArgs), configResult, defaults, serverArgs);
+      return {};
     }
 
-    if (_lodash.default.isEmpty(rules)) {
-      _logger.default.warn(`Found no log filtering rules in '${args.logFilters}'. Is that expected?`);
-    } else {
-      _logger.default.info(`Loaded ${_appiumSupport.util.pluralize('filtering rule', rules.length, true)} from '${args.logFilters}'`);
+    await (0, _logsink.init)(serverArgs);
+
+    if (serverArgs.logFilters) {
+      const {
+        issues,
+        rules
+      } = await _support.logger.loadSecureValuesPreprocessingRules(serverArgs.logFilters);
+
+      if (!_lodash.default.isEmpty(issues)) {
+        throw new Error(`The log filtering rules config '${serverArgs.logFilters}' has issues: ` + JSON.stringify(issues, null, 2));
+      }
+
+      if (_lodash.default.isEmpty(rules)) {
+        _logger.default.warn(`Found no log filtering rules in '${serverArgs.logFilters}'. Is that expected?`);
+      } else {
+        _logger.default.info(`Loaded ${_support.util.pluralize('filtering rule', rules.length, true)} from '${serverArgs.logFilters}'`);
+      }
     }
+
+    const appiumDriver = new _appium.AppiumDriver(serverArgs);
+    appiumDriver.driverConfig = driverConfig;
+    await preflightChecks(serverArgs, throwInsteadOfExit);
+    return {
+      appiumDriver,
+      parsedArgs: serverArgs,
+      driverConfig,
+      pluginConfig
+    };
   }
+}
 
-  let appiumDriver = new _appium.AppiumDriver(args);
-  const driverConfig = new _driverConfig.default(args.appiumHome);
-  const pluginConfig = new _pluginConfig.default(args.appiumHome);
-  appiumDriver.driverConfig = driverConfig;
-  await preflightChecks({
-    parser,
-    args,
-    driverConfig,
+async function main(args) {
+  const {
+    appiumDriver,
+    parsedArgs,
     pluginConfig,
-    throwInsteadOfExit
-  });
-  await logStartupInfo(parser, args);
-  let routeConfiguringFunction = (0, _appiumBaseDriver.routeConfiguringFunction)(appiumDriver);
-  const plugins = Object.keys(pluginConfig.installedExtensions).filter(pluginName => _lodash.default.includes(args.plugins, pluginName) || args.plugins.length === 1 && args.plugins[0] === _args.USE_ALL_PLUGINS).map(pluginName => {
-    try {
-      const PluginClass = pluginConfig.require(pluginName);
-
-      return new PluginClass(pluginName);
-    } catch (err) {
-      _logger.default.error(`Could not load plugin '${pluginName}', so it will not be available. Error ` + `in loading the plugin was: ${err}`);
-
-      return false;
-    }
-  }).filter(Boolean);
-  appiumDriver.plugins = plugins;
-  let server = await (0, _appiumBaseDriver.server)({
+    driverConfig
+  } = await init(args);
+
+  if (!appiumDriver || !parsedArgs || !pluginConfig || !driverConfig) {
+    return;
+  }
+
+  const pluginClasses = (0, _extension2.getActivePlugins)(pluginConfig, parsedArgs.usePlugins);
+  appiumDriver.pluginClasses = pluginClasses;
+  await logStartupInfo(parsedArgs);
+  let routeConfiguringFunction = (0, _baseDriver.routeConfiguringFunction)(appiumDriver);
+  const driverClasses = (0, _extension2.getActiveDrivers)(driverConfig, parsedArgs.useDrivers);
+  const serverUpdaters = getServerUpdaters(driverClasses, pluginClasses);
+  const extraMethodMap = getExtraMethodMap(driverClasses, pluginClasses);
+  const serverOpts = {
     routeConfiguringFunction,
-    port: args.port,
-    hostname: args.address,
-    allowCors: args.allowCors,
-    basePath: args.basePath,
-    plugins
-  });
-
-  if (args.allowCors) {
+    port: parsedArgs.port,
+    hostname: parsedArgs.address,
+    allowCors: parsedArgs.allowCors,
+    basePath: parsedArgs.basePath,
+    serverUpdaters,
+    extraMethodMap
+  };
+
+  if (parsedArgs.keepAliveTimeout) {
+    serverOpts.keepAliveTimeout = parsedArgs.keepAliveTimeout * 1000;
+  }
+
+  let server;
+
+  try {
+    server = await (0, _baseDriver.server)(serverOpts);
+  } catch (err) {
+    _logger.default.error(`Could not configure Appium server. It's possible that a driver or plugin tried ` + `to update the server and failed. Original error: ${err.message}`);
+
+    _logger.default.debug(err.stack);
+
+    return process.exit(1);
+  }
+
+  if (parsedArgs.allowCors) {
     _logger.default.warn('You have enabled CORS requests from any host. Be careful not ' + 'to visit sites which could maliciously try to start Appium ' + 'sessions on your machine');
   }
 
   appiumDriver.server = server;
 
   try {
-    if (args.nodeconfig !== null) {
-      await (0, _gridRegister.default)(args.nodeconfig, args.address, args.port, args.basePath);
+    if (parsedArgs.nodeconfig) {
+      await (0, _gridRegister.default)(parsedArgs.nodeconfig, parsedArgs.address, parsedArgs.port, parsedArgs.basePath);
     }
   } catch (err) {
     await server.close();
@@ -228,15 +329,13 @@ async function main(args = null) {
     });
   }
 
-  logServerPort(args.address, args.port);
+  logServerPort(parsedArgs.address, parsedArgs.port);
   driverConfig.print();
-  pluginConfig.print(plugins);
+  pluginConfig.print(pluginClasses.map(p => p.pluginName));
   return server;
 }
 
 if (require.main === module) {
   (0, _asyncbox.asyncify)(main);
-}require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/main.js"],"names":["preflightChecks","parser","args","driverConfig","pluginConfig","throwInsteadOfExit","longStacktrace","require","async_trace_limit","showConfig","process","exit","read","tmpDir","err","logger","error","message","red","logNonDefaultArgsWarning","info","logDefaultCapabilitiesWarning","caps","logStartupInfo","welcome","APPIUM_VER","appiumRev","showArgs","_","size","isEmpty","defaultCapabilities","logServerPort","address","port","logMessage","main","Object","assign","parseArgs","subcommand","DRIVER_TYPE","PLUGIN_TYPE","logFilters","issues","rules","logFactory","loadSecureValuesPreprocessingRules","Error","JSON","stringify","warn","util","pluralize","length","appiumDriver","AppiumDriver","DriverConfig","appiumHome","PluginConfig","routeConfiguringFunction","plugins","keys","installedExtensions","filter","pluginName","includes","USE_ALL_PLUGINS","map","PluginClass","Boolean","server","hostname","allowCors","basePath","nodeconfig","close","signal","once","onSignal","deleteAllSessions","force","reason","e","print","module"],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n// transpile:main\n\nimport { init as logsinkInit } from './logsink';\nimport logger from './logger'; // logger needs to remain first of imports\nimport _ from 'lodash';\nimport { server as baseServer, routeConfiguringFunction as makeRouter } from 'appium-base-driver';\nimport { asyncify } from 'asyncbox';\nimport { default as getParser, getDefaultServerArgs } from './cli/parser';\nimport { USE_ALL_PLUGINS } from './cli/args';\nimport { logger as logFactory, util } from 'appium-support';\nimport {\n  showConfig, checkNodeOk, validateServerArgs,\n  warnNodeDeprecations, validateTmpDir, getNonDefaultArgs,\n  getGitRev, APPIUM_VER\n} from './config';\nimport DriverConfig from './driver-config';\nimport PluginConfig from './plugin-config';\nimport { DRIVER_TYPE, PLUGIN_TYPE } from './extension-config';\nimport { runExtensionCommand } from './cli/extension';\nimport { AppiumDriver } from './appium';\nimport registerNode from './grid-register';\nimport { inspectObject } from './utils';\n\n\nasync function preflightChecks ({parser, args, driverConfig, pluginConfig, throwInsteadOfExit = false}) {\n  try {\n    checkNodeOk();\n    if (args.longStacktrace) {\n      require('longjohn').async_trace_limit = -1;\n    }\n    if (args.showConfig) {\n      await showConfig();\n      process.exit(0);\n    }\n    warnNodeDeprecations();\n    validateServerArgs(parser, args);\n    await driverConfig.read();\n    await pluginConfig.read();\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\nfunction logNonDefaultArgsWarning (args) {\n  logger.info('Non-default server args:');\n  inspectObject(args);\n}\n\nfunction logDefaultCapabilitiesWarning (caps) {\n  logger.info('Default capabilities, which will be added to each request ' +\n              'unless overridden by desired capabilities:');\n  inspectObject(caps);\n}\n\nasync function logStartupInfo (parser, 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 = getNonDefaultArgs(parser, 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\nfunction logServerPort (address, port) {\n  let logMessage = `Appium REST http interface listener started on ` +\n                   `${address}:${port}`;\n  logger.info(logMessage);\n}\n\nasync function main (args = null) {\n  let parser = getParser();\n  let throwInsteadOfExit = false;\n  if (args) {\n    // a containing package passed in their own args, let's fill them out\n    // with defaults\n    args = Object.assign({}, getDefaultServerArgs(), args);\n\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  } else {\n    // otherwise parse from CLI\n    args = parser.parseArgs();\n  }\n  await logsinkInit(args);\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 (args.subcommand === DRIVER_TYPE || args.subcommand === PLUGIN_TYPE) {\n    await runExtensionCommand(args, args.subcommand);\n    process.exit();\n  }\n\n  if (args.logFilters) {\n    const {issues, rules} = await logFactory.loadSecureValuesPreprocessingRules(args.logFilters);\n    if (!_.isEmpty(issues)) {\n      throw new Error(`The log filtering rules config '${args.logFilters}' has issues: ` +\n        JSON.stringify(issues, null, 2));\n    }\n    if (_.isEmpty(rules)) {\n      logger.warn(`Found no log filtering rules in '${args.logFilters}'. Is that expected?`);\n    } else {\n      logger.info(`Loaded ${util.pluralize('filtering rule', rules.length, true)} from '${args.logFilters}'`);\n    }\n  }\n\n  let appiumDriver = new AppiumDriver(args);\n  const driverConfig = new DriverConfig(args.appiumHome);\n  const pluginConfig = new PluginConfig(args.appiumHome);\n  appiumDriver.driverConfig = driverConfig;\n  await preflightChecks({parser, args, driverConfig, pluginConfig, throwInsteadOfExit});\n  await logStartupInfo(parser, args);\n  let routeConfiguringFunction = makeRouter(appiumDriver);\n\n  // find any plugin name which has been installed, and which has been requested for activation by\n  // using the --plugins flag, and turn each one into an instantiated plugin object, so we can send\n  // them as objects to the server init. we also want to send/assign them to the umbrella driver so\n  // it can use them to wrap command execution\n  const plugins = Object.keys(pluginConfig.installedExtensions).filter((pluginName) =>\n    _.includes(args.plugins, pluginName) ||\n    (args.plugins.length === 1 && args.plugins[0] === USE_ALL_PLUGINS)\n  ).map((pluginName) => {\n    try {\n      const PluginClass = pluginConfig.require(pluginName);\n      return new PluginClass(pluginName);\n    } catch (err) {\n      logger.error(`Could not load plugin '${pluginName}', so it will not be available. Error ` +\n                   `in loading the plugin was: ${err}`);\n      return false;\n    }\n  }).filter(Boolean);\n  appiumDriver.plugins = plugins;\n\n  let server = await baseServer({\n    routeConfiguringFunction,\n    port: args.port,\n    hostname: args.address,\n    allowCors: args.allowCors,\n    basePath: args.basePath,\n    plugins,\n  });\n  if (args.allowCors) {\n    logger.warn('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  appiumDriver.server = server;\n  try {\n    // TODO prelaunch if args.launch is set\n    // TODO: startAlertSocket(server, appiumServer);\n\n    // configure as node on grid, if necessary\n    if (args.nodeconfig !== null) {\n      await registerNode(args.nodeconfig, args.address, args.port, args.basePath);\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(args.address, args.port);\n  driverConfig.print();\n  pluginConfig.print(plugins);\n\n  return server;\n}\n\nif (require.main === module) {\n  asyncify(main);\n}\n\nexport { main };\n"],"file":"lib/main.js","sourceRoot":"../.."}
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["resolveAppiumHome","env","preflightChecks","args","throwInsteadOfExit","longStacktrace","require","async_trace_limit","showBuildInfo","process","exit","tmpDir","err","logger","error","message","red","logNonDefaultArgsWarning","info","logDefaultCapabilitiesWarning","caps","logStartupInfo","welcome","APPIUM_VER","appiumRev","showArgs","_","size","isEmpty","defaultCapabilities","logServerPort","address","port","logMessage","getServerUpdaters","driverClasses","pluginClasses","compact","map","getExtraMethodMap","reduce","klass","newMethodMap","areServerCommandArgs","subcommand","SERVER_SUBCOMMAND","init","appiumHome","driverConfig","pluginConfig","parser","preConfigArgs","parseArgs","configResult","configFile","errors","Error","filepath","reason","DRIVER_TYPE","PLUGIN_TYPE","defaults","serverArgs","defaultsDeep","config","server","showConfig","logFilters","issues","rules","logFactory","loadSecureValuesPreprocessingRules","JSON","stringify","warn","util","pluralize","length","appiumDriver","AppiumDriver","parsedArgs","main","usePlugins","routeConfiguringFunction","useDrivers","serverUpdaters","extraMethodMap","serverOpts","hostname","allowCors","basePath","keepAliveTimeout","debug","stack","nodeconfig","close","signal","once","onSignal","deleteAllSessions","force","e","print","p","pluginName","module"],"sources":["../../lib/main.js"],"sourcesContent":["#!/usr/bin/env node\n\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 { APPIUM_VER, checkNodeOk, getGitRev, getNonDefaultServerArgs, showConfig, showBuildInfo, validateTmpDir, warnNodeDeprecations } 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';\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    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('Default capabilities, which will be added to each request ' +\n              'unless overridden by desired capabilities:');\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 ` +\n                   `${address}:${port}`;\n  logger.info(logMessage);\n}\n\n/**\n * Gets a list of `updateServer` functions from all extensions\n * @param {DriverClass[]} driverClasses\n * @param {PluginClass[]} pluginClasses\n * @returns {import('@appium/base-driver/lib/basedriver/driver').UpdateServerCallback[]}\n */\nfunction getServerUpdaters (driverClasses, pluginClasses) {\n  return _.compact(_.map([...driverClasses, ...pluginClasses], 'updateServer'));\n}\n\n/**\n * Makes a big `MethodMap` from all the little `MethodMap`s in the extensions\n * @param {DriverClass[]} driverClasses\n * @param {PluginClass[]} pluginClasses\n * @returns {import('@appium/types').MethodMap}\n */\nfunction getExtraMethodMap (driverClasses, pluginClasses) {\n  return [...driverClasses, ...pluginClasses].reduce(\n    (map, klass) => ({...map, .../** @type {DriverClass} */(klass).newMethodMap ?? {}}),\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  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(`Errors in config file ${configResult.filepath}:\\n ${configResult.reason ?? configResult.errors}`);\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\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(\n      preConfigArgs,\n      configResult.config?.server,\n      defaults\n    );\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(serverArgs.logFilters);\n      if (!_.isEmpty(issues)) {\n        throw new Error(`The log filtering rules config '${serverArgs.logFilters}' has issues: ` +\n        JSON.stringify(issues, null, 2));\n      }\n      if (_.isEmpty(rules)) {\n        logger.warn(`Found no log filtering rules in '${serverArgs.logFilters}'. Is that expected?`);\n      } else {\n        logger.info(`Loaded ${util.pluralize('filtering rule', rules.length, true)} from '${serverArgs.logFilters}'`);\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} */({appiumDriver, parsedArgs: serverArgs, driverConfig, pluginConfig});\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} */(await init(args));\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(`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    logger.debug(err.stack);\n    return process.exit(1);\n  }\n\n  if (parsedArgs.allowCors) {\n    logger.warn('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  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(parsedArgs.nodeconfig, parsedArgs.address, parsedArgs.port, parsedArgs.basePath);\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.map((p) => p.pluginName));\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('../types').DriverType} DriverType\n * @typedef {import('../types').PluginType} PluginType\n * @typedef {import('../types').DriverClass} DriverClass\n * @typedef {import('../types').PluginClass} PluginClass\n * @typedef {import('../types').WithServerSubcommand} WithServerSubcommand\n */\n\n/**\n * Literally an empty object\n * @typedef { {} } ExtCommandInitResult\n */\n\n/**\n * @typedef ServerInitData\n * @property {AppiumDriver} appiumDriver - The Appium driver\n * @property {import('../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('../types').Args<T>} Args\n */\n\n/**\n * @template [T=WithServerSubcommand]\n * @typedef {import('../types').ParsedArgs<T>} ParsedArgs\n */\n\n"],"mappings":"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"}

package/build/lib/schema/arg-spec.d.ts

@@ -0,0 +1,143 @@
+/**
+ * The original ID of the Appium config schema.
+ * We use this in the CLI to convert it to `argparse` options.
+ */
+export const APPIUM_CONFIG_SCHEMA_ID: "appium.json";
+/**
+ * The schema prop containing server-related options. Everything in here
+ * is "native" to Appium.
+ * Used by {@link flattenSchema} for transforming the schema into CLI args.
+ */
+export const SERVER_PROP_NAME: "server";
+/**
+ * An `ArgSpec` is a class representing metadata about an argument (or config
+ * option) used for cross-referencing.
+ *
+ * This class has no instance methods, and is basically just a read-only "struct".
+ * @template D
+ */
+export class ArgSpec<D> {
+    /**
+     * Return the schema ID (`$id`) for the **argument** given the parameters.
+     *
+     * If you need the "root" or "base" schema ID, use {@link ArgSpec.toSchemaBaseRef} instead.
+     * @param {string} name - Argument name
+     * @param {ExtensionType} [extType] - Extension type
+     * @param {string} [extName] - Extension name
+     * @returns {string} Schema ID
+     */
+    static toSchemaRef(name: string, extType?: import("../../types").ExtensionType | undefined, extName?: string | undefined): string;
+    /**
+     * Return the schema ID for an extension or the base schema ID.
+     * @param {ExtensionType} [extType] - Extension type
+     * @param {string} [extName] - Extension name
+     */
+    static toSchemaBaseRef(extType?: import("../../types").ExtensionType | undefined, extName?: string | undefined): string;
+    /**
+     * Return the unique ID for the argument given the parameters.
+     * @param {string} name - Argument name
+     * @param {ExtensionType} [extType] - Extension type
+     * @param {string} [extName] - Extension name
+     * @returns {string} Unique ID
+     */
+    static toArg(name: string, extType?: import("../../types").ExtensionType | undefined, extName?: string | undefined): string;
+    /**
+     * Normalizes a raw extension name (not including the type).
+     * @param {string} extName - Extension name
+     * @returns {string} Normalized extension name
+     */
+    static toNormalizedExtName(extName: string): string;
+    /**
+     * When given the root ID of a schema for an extension (`<extType>-<normalizedExtName>.json`) Returns an object containing the extension type and the _normalized_ extension name.
+     * @param {string} schemaId - Root schema ID
+     * @returns { {extType?: ExtensionType, normalizedExtName?: string} }
+     */
+    static extensionInfoFromRootSchemaId(schemaId: string): {
+        extType?: ExtensionType;
+        normalizedExtName?: string;
+    };
+    /**
+     * Creates an `ArgSpec`
+     *
+     * @param {string} name - The canonical name of the argument. Corresponds to a key in a schema's
+     * `properties` property.
+     * @template D
+     * @param {ArgSpecOptions<D>} [opts] - Options
+     * @returns {Readonly<ArgSpec>}
+     */
+    static create<D_1>(name: string, opts?: ArgSpecOptions<D_1> | undefined): Readonly<ArgSpec<any>>;
+    /**
+     * Builds some computed fields and assigns them to the instance.
+     *
+     * Undefined properties are not assigned.
+     *
+     * The _constructor_ is private. Use {@link ArgSpec.create} instead.
+     * @private
+     * @param {string} name
+     * @param {ArgSpecOptions<D>} [opts]
+     */
+    private constructor();
+    /**
+     * The canonical name of the argument. Corresponds to key in schema's `properties` prop.
+     * @type {string}
+     */
+    name: string;
+    /**
+     * The `ExtensionType` of the argument. This will be set if the arg came from an extension;
+     * otherwise it will be `undefined`.
+     * @type {ExtensionType|undefined}
+     */
+    extType: ExtensionType | undefined;
+    /**
+     * The name of the extension, if this argument came from an extension.
+     *
+     * Otherwise `undefined`.
+     * @type {string|undefined}
+     */
+    extName: string | undefined;
+    /**
+     * The schema ID (`$id`) for the argument.  This is automatically determined, and any user-provided `$id`s will be overwritten.
+     *
+     * @type {string}
+     */
+    ref: string;
+    /**
+     * The CLI argument, sans leading dashes.
+     * @type {string}
+     */
+    arg: string;
+    /**
+     * The desired keypath for the argument after arguments have been parsed.
+     *
+     * Typically this is camelCased.  If the arg came from an extension, it will be prefixed with
+     * `<extType>.<extName>.`
+     * @type {string}
+     */
+    dest: string;
+    /**
+     * The same as {@link ArgSpec.dest} but without the leading `<extType>.<extName>.` prefix.
+     */
+    rawDest: string;
+    /**
+     * Whatever the default value of this argument is, as specified by the
+     * `default` property of the schema.
+     * @type {D|undefined}
+     */
+    defaultValue: D | undefined;
+    /**
+     * String representation, useful for debugging
+     * @returns {string}
+     */
+    toString(): string;
+}
+/**
+ * Options for {@link ArgSpec.create }
+ */
+export type ArgSpecOptions<D> = {
+    extName?: string | undefined;
+    extType?: import("../../types").ExtensionType | undefined;
+    dest?: string | undefined;
+    defaultValue?: D | undefined;
+};
+export type ExtensionType = import('../extension/manifest').ExtensionType;
+//# sourceMappingURL=arg-spec.d.ts.map

package/build/lib/schema/arg-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arg-spec.d.ts","sourceRoot":"","sources":["../../../lib/schema/arg-spec.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oDAAqD;AAErD;;;;GAIG;AACH,wCAAyC;AAYzC;;;;;;GAMG;AACH;IA0FE;;;;;;;;OAQG;IACH,yBALW,MAAM,4FAGJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,wHAKC;IAED;;;;;;OAMG;IACH,mBALW,MAAM,4FAGJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,oCAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,+CAHW,MAAM,GACH;QAAC,OAAO,CAAC,EAAE,aAAa,CAAC;QAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;KAAC,CAYlE;IAED;;;;;;;;OAQG;IACH,yBANW,MAAM,2CAIJ,sBAAiB,CAI7B;IAnHD;;;;;;;;;OASG;IACH,sBAsBC;IAvFD;;;OAGG;IACH,MAFU,MAAM,CAEX;IAEL;;;;OAIG;IACH,SAFU,aAAa,GAAC,SAAS,CAEzB;IAER;;;;;OAKG;IACH,SAFU,MAAM,GAAC,SAAS,CAElB;IAER;;;;OAIG;IACH,KAFU,MAAM,CAEZ;IAEJ;;;OAGG;IACH,KAFU,MAAM,CAEZ;IAEJ;;;;;;OAMG;IACH,MAFU,MAAM,CAEX;IAEL;;OAEG;IACH,gBAAQ;IAER;;;;OAIG;IACH,cAFU,CAAC,GAAC,SAAS,CAER;IAuHb;;;OAGG;IAEH,YAHa,MAAM,CASlB;CACF;;;;;;;;;;4BAaY,OAAO,uBAAuB,EAAE,aAAa"}