appium 2.0.0-beta.2 → 2.0.0-beta.23

package/build/lib/main.js

@@ -1,56 +1,83 @@
 #!/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, "APPIUM_HOME", {
+  enumerable: true,
+  get: function () {
+    return _extensionConfig.APPIUM_HOME;
+  }
+});
+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;
+  }
+});
+Object.defineProperty(exports, "validate", {
+  enumerable: true,
+  get: function () {
+    return _schema.validate;
+  }
+});
 
 require("source-map-support/register");
 
-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 _appiumSupport = require("appium-support");
+var _extension = require("./cli/extension");
+
+var _parser = _interopRequireWildcard(require("./cli/parser"));
 
 var _config = require("./config");
 
-var _driverConfig = _interopRequireDefault(require("./driver-config"));
-
-var _pluginConfig = _interopRequireDefault(require("./plugin-config"));
+var _configFile = require("./config-file");
 
 var _extensionConfig = require("./extension-config");
 
-var _extension = require("./cli/extension");
+var _gridRegister = _interopRequireDefault(require("./grid-register"));
 
-var _appium = require("./appium");
+var _logger = _interopRequireDefault(require("./logger"));
 
-var _gridRegister = _interopRequireDefault(require("./grid-register"));
+var _logsink = require("./logsink");
+
+var _schema = require("./schema/schema");
 
 var _utils = require("./utils");
 
-async function preflightChecks({
-  parser,
-  args,
-  driverConfig,
-  pluginConfig,
-  throwInsteadOfExit = false
-}) {
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+async function preflightChecks(args, throwInsteadOfExit = false) {
   try {
     (0, _config.checkNodeOk)();
 
@@ -64,9 +91,7 @@ async function preflightChecks({
     }
 
     (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);
@@ -104,7 +129,7 @@ async function logStartupInfo(parser, args) {
 
   _logger.default.info(welcome);
 
-  let showArgs = (0, _config.getNonDefaultArgs)(parser, args);
+  let showArgs = (0, _config.getNonDefaultServerArgs)(parser, args);
 
   if (_lodash.default.size(showArgs)) {
     logNonDefaultArgsWarning(showArgs);
@@ -121,88 +146,180 @@ function logServerPort(address, port) {
   _logger.default.info(logMessage);
 }
 
-async function main(args = null) {
-  let parser = (0, _parser.default)();
+function getActivePlugins(args, pluginConfig) {
+  return _lodash.default.compact(Object.keys(pluginConfig.installedExtensions).filter(pluginName => _lodash.default.includes(args.usePlugins, pluginName) || args.usePlugins.length === 1 && args.usePlugins[0] === _args.USE_ALL_PLUGINS).map(pluginName => {
+    try {
+      _logger.default.info(`Attempting to load plugin ${pluginName}...`);
+
+      const PluginClass = pluginConfig.require(pluginName);
+
+      PluginClass.pluginName = pluginName;
+      return PluginClass;
+    } catch (err) {
+      _logger.default.error(`Could not load plugin '${pluginName}', so it will not be available. Error ` + `in loading the plugin was: ${err.message}`);
+
+      _logger.default.debug(err.stack);
+    }
+  }));
+}
+
+function getActiveDrivers(args, driverConfig) {
+  return _lodash.default.compact(Object.keys(driverConfig.installedExtensions).filter(driverName => _lodash.default.includes(args.useDrivers, driverName) || args.useDrivers.length === 0).map(driverName => {
+    try {
+      _logger.default.info(`Attempting to load driver ${driverName}...`);
+
+      return driverConfig.require(driverName);
+    } catch (err) {
+      _logger.default.error(`Could not load driver '${driverName}', so it will not be available. Error ` + `in loading the driver was: ${err.message}`);
+
+      _logger.default.debug(err.stack);
+    }
+  }));
+}
+
+function getServerUpdaters(driverClasses, pluginClasses) {
+  return [...driverClasses, ...pluginClasses].map(klass => klass.updateServer).filter(Boolean);
+}
+
+function getExtraMethodMap(driverClasses, pluginClasses) {
+  return [...driverClasses, ...pluginClasses].reduce((map, klass) => ({ ...map,
+    ...klass.newMethodMap
+  }), {});
+}
+
+async function init(args) {
+  var _configResult$config2;
+
+  const parser = await (0, _parser.default)();
   let throwInsteadOfExit = false;
+  let parsedArgs;
 
   if (args) {
-    args = Object.assign({}, (0, _parser.getDefaultServerArgs)(), args);
+    var _args$subcommand;
 
     if (args.throwInsteadOfExit) {
       throwInsteadOfExit = true;
       delete args.throwInsteadOfExit;
     }
+
+    parsedArgs = { ...args,
+      subcommand: (_args$subcommand = args.subcommand) !== null && _args$subcommand !== void 0 ? _args$subcommand : _parser.SERVER_SUBCOMMAND
+    };
   } else {
-    args = parser.parseArgs();
+    parsedArgs = parser.parseArgs();
+  }
+
+  const configResult = await (0, _configFile.readConfigFile)(parsedArgs.configFile);
+
+  if (!_lodash.default.isEmpty(configResult.errors)) {
+    var _configResult$reason;
+
+    throw new Error(`Errors in config file ${configResult.filepath}:\n ${(_configResult$reason = configResult.reason) !== null && _configResult$reason !== void 0 ? _configResult$reason : configResult.errors}`);
   }
 
-  await (0, _logsink.init)(args);
+  if (parsedArgs.subcommand === _parser.SERVER_SUBCOMMAND) {
+    var _configResult$config;
+
+    parsedArgs = _lodash.default.defaultsDeep(parsedArgs, (_configResult$config = configResult.config) === null || _configResult$config === void 0 ? void 0 : _configResult$config.server, (0, _schema.getDefaultsFromSchema)());
+  }
+
+  parsedArgs = _lodash.default.defaultsDeep(parsedArgs, (_configResult$config2 = configResult.config) !== null && _configResult$config2 !== void 0 ? _configResult$config2 : {});
+  await (0, _logsink.init)(parsedArgs);
+
+  if (parsedArgs.subcommand === _extensionConfig.DRIVER_TYPE) {
+    await (0, _extension.runExtensionCommand)(parsedArgs, parsedArgs.subcommand, _args.driverConfig);
+    return {
+      parser
+    };
+  }
 
-  if (args.subcommand === _extensionConfig.DRIVER_TYPE || args.subcommand === _extensionConfig.PLUGIN_TYPE) {
-    await (0, _extension.runExtensionCommand)(args, args.subcommand);
-    process.exit();
+  if (parsedArgs.subcommand === _extensionConfig.PLUGIN_TYPE) {
+    await (0, _extension.runExtensionCommand)(parsedArgs, parsedArgs.subcommand, _args.pluginConfig);
+    return {
+      parser
+    };
   }
 
-  if (args.logFilters) {
+  if (parsedArgs.logFilters) {
     const {
       issues,
       rules
-    } = await _appiumSupport.logger.loadSecureValuesPreprocessingRules(args.logFilters);
+    } = await _support.logger.loadSecureValuesPreprocessingRules(parsedArgs.logFilters);
 
     if (!_lodash.default.isEmpty(issues)) {
-      throw new Error(`The log filtering rules config '${args.logFilters}' has issues: ` + JSON.stringify(issues, null, 2));
+      throw new Error(`The log filtering rules config '${parsedArgs.logFilters}' has issues: ` + JSON.stringify(issues, null, 2));
     }
 
     if (_lodash.default.isEmpty(rules)) {
-      _logger.default.warn(`Found no log filtering rules in '${args.logFilters}'. Is that expected?`);
+      _logger.default.warn(`Found no log filtering rules in '${parsedArgs.logFilters}'. Is that expected?`);
     } else {
-      _logger.default.info(`Loaded ${_appiumSupport.util.pluralize('filtering rule', rules.length, true)} from '${args.logFilters}'`);
+      _logger.default.info(`Loaded ${_support.util.pluralize('filtering rule', rules.length, true)} from '${parsedArgs.logFilters}'`);
     }
   }
 
-  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({
+  const appiumDriver = new _appium.AppiumDriver(parsedArgs);
+  appiumDriver.driverConfig = _args.driverConfig;
+  await preflightChecks(parsedArgs, throwInsteadOfExit);
+  return {
     parser,
-    args,
-    driverConfig,
-    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);
+    appiumDriver,
+    parsedArgs
+  };
+}
 
-      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}`);
+async function main(args) {
+  const {
+    parser,
+    appiumDriver,
+    parsedArgs
+  } = await init(args);
 
-      return false;
-    }
-  }).filter(Boolean);
-  appiumDriver.plugins = plugins;
-  let server = await (0, _appiumBaseDriver.server)({
+  if (!appiumDriver || !parsedArgs) {
+    return;
+  }
+
+  const pluginClasses = getActivePlugins(parsedArgs, _args.pluginConfig);
+  appiumDriver.pluginClasses = pluginClasses;
+  await logStartupInfo(parser, parsedArgs);
+  let routeConfiguringFunction = (0, _baseDriver.routeConfiguringFunction)(appiumDriver);
+  const driverClasses = getActiveDrivers(parsedArgs, _args.driverConfig);
+  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);
+    if (parsedArgs.nodeconfig) {
+      await (0, _gridRegister.default)(parsedArgs.nodeconfig, parsedArgs.address, parsedArgs.port, parsedArgs.basePath);
     }
   } catch (err) {
     await server.close();
@@ -228,9 +345,12 @@ async function main(args = null) {
     });
   }
 
-  logServerPort(args.address, args.port);
-  driverConfig.print();
-  pluginConfig.print(plugins);
+  logServerPort(parsedArgs.address, parsedArgs.port);
+
+  _args.driverConfig.print();
+
+  _args.pluginConfig.print(pluginClasses.map(p => p.pluginName));
+
   return server;
 }
 
@@ -239,4 +359,4 @@ if (require.main === module) {
 }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);\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=utf8;base64,{"version":3,"sources":["lib/main.js"],"names":["preflightChecks","args","throwInsteadOfExit","longStacktrace","require","async_trace_limit","showConfig","process","exit","tmpDir","err","logger","error","message","red","logNonDefaultArgsWarning","info","logDefaultCapabilitiesWarning","caps","logStartupInfo","parser","welcome","APPIUM_VER","appiumRev","showArgs","_","size","isEmpty","defaultCapabilities","logServerPort","address","port","logMessage","getActivePlugins","pluginConfig","compact","Object","keys","installedExtensions","filter","pluginName","includes","usePlugins","length","USE_ALL_PLUGINS","map","PluginClass","debug","stack","getActiveDrivers","driverConfig","driverName","useDrivers","getServerUpdaters","driverClasses","pluginClasses","klass","updateServer","Boolean","getExtraMethodMap","reduce","newMethodMap","init","parsedArgs","subcommand","SERVER_SUBCOMMAND","parseArgs","configResult","configFile","errors","Error","filepath","reason","defaultsDeep","config","server","DRIVER_TYPE","PLUGIN_TYPE","logFilters","issues","rules","logFactory","loadSecureValuesPreprocessingRules","JSON","stringify","warn","util","pluralize","appiumDriver","AppiumDriver","main","routeConfiguringFunction","serverUpdaters","extraMethodMap","serverOpts","hostname","allowCors","basePath","keepAliveTimeout","nodeconfig","close","signal","once","onSignal","deleteAllSessions","force","e","print","p","module"],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n\n// transpile:main\n// @ts-check\n\n// @ts-ignore\nimport { routeConfiguringFunction as makeRouter, server as baseServer } from '@appium/base-driver';\nimport { logger as logFactory, util } from '@appium/support';\nimport { asyncify } from 'asyncbox';\nimport _ from 'lodash';\nimport { AppiumDriver } from './appium';\nimport { driverConfig, pluginConfig, USE_ALL_PLUGINS } from './cli/args';\nimport { runExtensionCommand } from './cli/extension';\nimport { default as getParser, SERVER_SUBCOMMAND } from './cli/parser';\nimport { APPIUM_VER, checkNodeOk, getGitRev, getNonDefaultServerArgs, showConfig, validateTmpDir, warnNodeDeprecations } from './config';\nimport { readConfigFile } from './config-file';\nimport { DRIVER_TYPE, PLUGIN_TYPE } from './extension-config';\nimport registerNode from './grid-register';\nimport logger from './logger'; // logger needs to remain first of imports\nimport { init as logsinkInit } from './logsink';\nimport { getDefaultsFromSchema, validate } from './schema/schema';\nimport { inspectObject } from './utils';\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.showConfig) {\n      await showConfig();\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\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 = getNonDefaultServerArgs(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\n/**\n * Find any plugin name which has been installed, and which has been requested for activation by\n * using the --use-plugins flag, and turn each one into its class, so we can send them as objects\n * to the server init. We also want to send/assign them to the umbrella driver so it can use them\n * to wrap command execution\n *\n * @param {Object} args - argparser parsed dict\n * @param {import('./plugin-config').default} pluginConfig - a plugin extension config\n * @returns {({pluginName: string} & ((...args: any[]) => unknown))[]}\n */\nfunction getActivePlugins (args, pluginConfig) {\n  return _.compact(Object.keys(pluginConfig.installedExtensions).filter((pluginName) =>\n    _.includes(args.usePlugins, pluginName) ||\n    (args.usePlugins.length === 1 && args.usePlugins[0] === USE_ALL_PLUGINS)\n  ).map((pluginName) => {\n    try {\n      logger.info(`Attempting to load plugin ${pluginName}...`);\n      const PluginClass = /** @type {{pluginName: string} & ((...args: any[]) => unknown)} */(pluginConfig.require(pluginName));\n\n      PluginClass.pluginName = pluginName; // store the plugin name on the class so it can be used later\n      return PluginClass;\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.message}`);\n      logger.debug(err.stack);\n    }\n  }));\n}\n\n/**\n * Find any driver name which has been installed, and turn each one into its class, so we can send\n * them as objects to the server init in case they need to add methods/routes or update the server.\n * If the --drivers flag was given, this method only loads the given drivers.\n *\n * @param {Object} args - argparser parsed dict\n * @param {import('./driver-config').default} driverConfig - a driver extension config\n */\nfunction getActiveDrivers (args, driverConfig) {\n  return _.compact(Object.keys(driverConfig.installedExtensions).filter((driverName) =>\n    _.includes(args.useDrivers, driverName) || args.useDrivers.length === 0\n  ).map((driverName) => {\n    try {\n      logger.info(`Attempting to load driver ${driverName}...`);\n      return driverConfig.require(driverName);\n    } catch (err) {\n      logger.error(`Could not load driver '${driverName}', so it will not be available. Error ` +\n                   `in loading the driver was: ${err.message}`);\n      logger.debug(err.stack);\n    }\n  }));\n}\n\nfunction getServerUpdaters (driverClasses, pluginClasses) {\n  return [...driverClasses, ...pluginClasses].map((klass) => klass.updateServer).filter(Boolean);\n}\n\nfunction getExtraMethodMap (driverClasses, pluginClasses) {\n  return [...driverClasses, ...pluginClasses].reduce(\n    (map, klass) => ({...map, ...klass.newMethodMap}),\n    {}\n  );\n}\n\n/**\n * Initializes Appium, but does not start the server.\n *\n * Use this to get at the configuration schema.\n *\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 * @param {ParsedArgs} [args] - Parsed args\n * @returns {Promise<{parser: import('./cli/parser').ArgParser} & Partial<{appiumDriver: AppiumDriver, parsedArgs: ParsedArgs}>>}\n */\nasync function init (args) {\n  const parser = await getParser();\n  let throwInsteadOfExit = false;\n  /** @type {ParsedArgs} */\n  let parsedArgs;\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    parsedArgs = {...args, subcommand: args.subcommand ?? SERVER_SUBCOMMAND};\n  } else {\n    // otherwise parse from CLI\n    parsedArgs = parser.parseArgs();\n  }\n\n  const configResult = await readConfigFile(parsedArgs.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 (parsedArgs.subcommand === SERVER_SUBCOMMAND) {\n    parsedArgs = _.defaultsDeep(\n      parsedArgs,\n      configResult.config?.server,\n      getDefaultsFromSchema()\n    );\n  }\n\n  parsedArgs = _.defaultsDeep(\n    parsedArgs,\n    configResult.config ?? {},\n  );\n\n  await logsinkInit(parsedArgs);\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 (parsedArgs.subcommand === DRIVER_TYPE) {\n    await runExtensionCommand(parsedArgs, parsedArgs.subcommand, driverConfig);\n    return {parser};\n  }\n  if (parsedArgs.subcommand === PLUGIN_TYPE) {\n    await runExtensionCommand(parsedArgs, parsedArgs.subcommand, pluginConfig);\n    return {parser};\n  }\n\n  if (parsedArgs.logFilters) {\n    const {issues, rules} = await logFactory.loadSecureValuesPreprocessingRules(parsedArgs.logFilters);\n    if (!_.isEmpty(issues)) {\n      throw new Error(`The log filtering rules config '${parsedArgs.logFilters}' has issues: ` +\n        JSON.stringify(issues, null, 2));\n    }\n    if (_.isEmpty(rules)) {\n      logger.warn(`Found no log filtering rules in '${parsedArgs.logFilters}'. Is that expected?`);\n    } else {\n      logger.info(`Loaded ${util.pluralize('filtering rule', rules.length, true)} from '${parsedArgs.logFilters}'`);\n    }\n  }\n\n  const appiumDriver = new AppiumDriver(parsedArgs);\n  // set the config on the umbrella driver so it can match drivers to caps\n  appiumDriver.driverConfig = driverConfig;\n  await preflightChecks(parsedArgs, throwInsteadOfExit);\n\n  return {parser, appiumDriver, parsedArgs};\n}\n\n/**\n *\n * @param {ParsedArgs} [args]\n * @returns\n */\nasync function main (args) {\n  const {parser, appiumDriver, parsedArgs} = await init(args);\n\n  if (!appiumDriver || !parsedArgs) {\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(parsedArgs, pluginConfig);\n  // set the active plugins on the umbrella driver so it can use them for commands\n  appiumDriver.pluginClasses = pluginClasses;\n\n  await logStartupInfo(parser, parsedArgs);\n  let routeConfiguringFunction = makeRouter(appiumDriver);\n\n  const driverClasses = getActiveDrivers(parsedArgs, driverConfig);\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  // @ts-ignore\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 { main, init };\nexport { APPIUM_HOME } from './extension-config';\nexport { getSchema, validate, finalizeSchema } from './schema/schema';\nexport { readConfigFile } from './config-file';\n\n/**\n * @typedef {import('../types/types').ParsedArgs} ParsedArgs\n */\n"],"file":"lib/main.js","sourceRoot":"../.."}

package/build/lib/plugin-config.js

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
-
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
 Object.defineProperty(exports, "__esModule", {
@@ -9,17 +7,29 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 require("source-map-support/register");
 
 var _lodash = _interopRequireDefault(require("lodash"));
 
-var _extensionConfig = _interopRequireWildcard(require("./extension-config"));
+var _extensionConfig = _interopRequireDefault(require("./extension-config"));
+
+var _extConfigIo = require("./ext-config-io");
 
 var _logger = _interopRequireDefault(require("./logger"));
 
 class PluginConfig extends _extensionConfig.default {
-  constructor(appiumHome, logFn = null) {
-    super(appiumHome, _extensionConfig.PLUGIN_TYPE, logFn);
+  constructor(appiumHome, logFn) {
+    super(appiumHome, _extConfigIo.PLUGIN_TYPE, logFn);
+  }
+
+  static getInstance(appiumHome, logFn) {
+    var _PluginConfig$_instan;
+
+    const instance = (_PluginConfig$_instan = PluginConfig._instances[appiumHome]) !== null && _PluginConfig$_instan !== void 0 ? _PluginConfig$_instan : new PluginConfig(appiumHome, logFn);
+    PluginConfig._instances[appiumHome] = instance;
+    return instance;
   }
 
   extensionDesc(pluginName, {
@@ -28,9 +38,8 @@ class PluginConfig extends _extensionConfig.default {
     return `${pluginName}@${version}`;
   }
 
-  print(activePlugins) {
+  print(activeNames) {
     const pluginNames = Object.keys(this.installedExtensions);
-    const activeNames = activePlugins.map(p => p.name);
 
     if (_lodash.default.isEmpty(pluginNames)) {
       _logger.default.info(`No plugins have been installed. Use the "appium plugin" ` + 'command to install the one(s) you want to use.');
@@ -46,14 +55,15 @@ class PluginConfig extends _extensionConfig.default {
       _logger.default.info(`  - ${this.extensionDesc(pluginName, pluginData)}${activeTxt}`);
     }
 
-    if (_lodash.default.isEmpty(activePlugins)) {
-      _logger.default.info('No plugins activated. Use the --plugins flag with names of plugins to activate');
+    if (_lodash.default.isEmpty(activeNames)) {
+      _logger.default.info('No plugins activated. Use the --use-plugins flag with names of plugins to activate');
     }
   }
 
 }
 
-exports.default = PluginConfig;require('source-map-support').install();
+exports.default = PluginConfig;
+(0, _defineProperty2.default)(PluginConfig, "_instances", {});require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/build/lib/plugins.js

@@ -7,8 +7,10 @@ exports.KNOWN_PLUGINS = void 0;
 
 require("source-map-support/register");
 
-const KNOWN_PLUGINS = {};
+const KNOWN_PLUGINS = {
+  images: '@appium/images-plugin'
+};
 exports.KNOWN_PLUGINS = KNOWN_PLUGINS;require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxpYi9wbHVnaW5zLmpzIl0sIm5hbWVzIjpbIktOT1dOX1BMVUdJTlMiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUlBLE1BQU1BLGFBQWEsR0FBRyxFQUF0QiIsInNvdXJjZXNDb250ZW50IjpbIi8vIFRoaXMgaXMgYSBtYXAgb2YgcGx1Z2luIG5hbWVzIHRvIG5wbSBwYWNrYWdlcyByZXByZXNlbnRpbmcgdGhvc2UgcGx1Z2lucy5cbi8vIFRoZSBwbHVnaW5zIGluIHRoaXMgbGlzdCB3aWxsIGJlIGF2YWlsYWJsZSB0byB0aGUgQ0xJIHNvIHVzZXJzIGNhbiBqdXN0XG4vLyB0eXBlICdhcHBpdW0gcGx1Z2luIGluc3RhbGwgJ25hbWUnJywgcmF0aGVyIHRoYW4gaGF2aW5nIHRvIHNwZWNpZnkgdGhlIGZ1bGxcbi8vIG5wbSBwYWNrYWdlLiBJLmUuLCB0aGVzZSBhcmUgdGhlIG9mZmljaWFsbHkgcmVjb2duaXplZCBwbHVnaW5zLlxuY29uc3QgS05PV05fUExVR0lOUyA9IHtcbn07XG5cbmV4cG9ydCB7XG4gIEtOT1dOX1BMVUdJTlMsXG59O1xuIl0sImZpbGUiOiJsaWIvcGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIuLi8uLiJ9
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxpYi9wbHVnaW5zLmpzIl0sIm5hbWVzIjpbIktOT1dOX1BMVUdJTlMiLCJpbWFnZXMiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUlBLE1BQU1BLGFBQWEsR0FBRztBQUNwQkMsRUFBQUEsTUFBTSxFQUFFO0FBRFksQ0FBdEIiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBUaGlzIGlzIGEgbWFwIG9mIHBsdWdpbiBuYW1lcyB0byBucG0gcGFja2FnZXMgcmVwcmVzZW50aW5nIHRob3NlIHBsdWdpbnMuXG4vLyBUaGUgcGx1Z2lucyBpbiB0aGlzIGxpc3Qgd2lsbCBiZSBhdmFpbGFibGUgdG8gdGhlIENMSSBzbyB1c2VycyBjYW4ganVzdFxuLy8gdHlwZSAnYXBwaXVtIHBsdWdpbiBpbnN0YWxsICduYW1lJycsIHJhdGhlciB0aGFuIGhhdmluZyB0byBzcGVjaWZ5IHRoZSBmdWxsXG4vLyBucG0gcGFja2FnZS4gSS5lLiwgdGhlc2UgYXJlIHRoZSBvZmZpY2lhbGx5IHJlY29nbml6ZWQgcGx1Z2lucy5cbmNvbnN0IEtOT1dOX1BMVUdJTlMgPSB7XG4gIGltYWdlczogJ0BhcHBpdW0vaW1hZ2VzLXBsdWdpbicsXG59O1xuXG5leHBvcnQge1xuICBLTk9XTl9QTFVHSU5TLFxufTtcbiJdLCJmaWxlIjoibGliL3BsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiLi4vLi4ifQ==