appium 2.0.0-beta.3 → 2.0.0-beta.30

package/lib/extension/plugin-config.js

@@ -0,0 +1,113 @@
+
+import _ from 'lodash';
+import {ExtensionConfig} from './extension-config';
+import log from '../logger';
+import {PLUGIN_TYPE} from '../constants';
+
+/**
+ * @extends {ExtensionConfig<PluginType>}
+ */
+export class PluginConfig extends ExtensionConfig {
+
+  /**
+   * A mapping of {@link Manifest} instances to {@link PluginConfig} instances.
+   *
+   * `Manifest` and {@link ExtensionConfig} have a one-to-many relationship; each `Manifest` should be associated with a `DriverConfig` and a `PluginConfig`; no more, no less.
+   *
+   * This variable tracks the `Manifest`-to-`PluginConfig` portion.
+   *
+   * @type {WeakMap<Manifest,PluginConfig>}
+   * @private
+   */
+   static _instances = new WeakMap();
+
+   /**
+   * Call {@link PluginConfig.create} instead.
+   *
+   * Just calls the superclass' constructor with the correct extension type
+   * @private
+   * @param {Manifest} manifest - IO object
+   * @param {PluginConfigOptions} [opts]
+   */
+   constructor (manifest, {extData, logFn} = {}) {
+     super(PLUGIN_TYPE, manifest, logFn);
+
+     if (extData) {
+       this.validate(extData);
+     }
+   }
+
+   /**
+    * Creates a new {@link PluginConfig} instance for a {@link Manifest} instance.
+    *
+    * @param {Manifest} manifest
+    * @param {PluginConfigOptions} [opts]
+    * @throws If `manifest` already associated with a `PluginConfig`
+    * @returns {PluginConfig}
+    */
+   static create (manifest, {extData, logFn} = {}) {
+     const instance = new PluginConfig(manifest, {logFn, extData});
+     if (PluginConfig.getInstance(manifest)) {
+       throw new Error(`Manifest with APPIUM_HOME ${manifest.appiumHome} already has a PluginConfig; use PluginConfig.getInstance() to retrieve it.`);
+     }
+     PluginConfig._instances.set(manifest, instance);
+     return instance;
+   }
+
+   /**
+     * Returns a PluginConfig associated with a Manifest
+     * @param {Manifest} manifest
+     * @returns {PluginConfig|undefined}
+     */
+   static getInstance (manifest) {
+     return PluginConfig._instances.get(manifest);
+   }
+
+   /**
+   * @param {string} pluginName
+   * @param {import('../../types/appium-manifest').ExtManifest<PluginType>} pluginData
+   * @returns {string}
+   */
+   extensionDesc (pluginName, {version}) {
+     return `${pluginName}@${version}`;
+   }
+
+   /**
+   *
+   * @param {(keyof PluginRecord)[]} activeNames
+   * @returns {void}
+   */
+   print (activeNames) {
+     const pluginNames = Object.keys(this.installedExtensions);
+
+     if (_.isEmpty(pluginNames)) {
+       log.info(`No plugins have been installed. Use the "appium plugin" ` +
+               'command to install the one(s) you want to use.');
+       return;
+     }
+
+     log.info(`Available plugins:`);
+     for (const [pluginName, pluginData] of _.toPairs(this.installedExtensions)) {
+       const activeTxt = _.includes(activeNames, pluginName) ? ' (ACTIVE)' : '';
+       log.info(`  - ${this.extensionDesc(pluginName, pluginData)}${activeTxt}`);
+     }
+
+     if (_.isEmpty(activeNames)) {
+       log.info('No plugins activated. Use the --use-plugins flag with names of plugins to activate');
+     }
+   }
+}
+
+/**
+ * @typedef PluginConfigOptions
+ * @property {import('./extension-config').ExtensionLogFn} [logFn] - Optional logging function
+ * @property {import('../../types/appium-manifest').PluginRecord} [extData] - Extension data
+ */
+
+
+/**
+ * @typedef {import('../../types/appium-manifest').PluginRecord} PluginRecord
+ * @typedef {import('../../types').PluginType} PluginType
+ * @typedef {import('../../types/external-manifest').ExtMetadata<PluginType>} PluginMetadata
+ * @typedef {import('./manifest').Manifest} Manifest
+ */

package/lib/grid-register.js

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import { fs } from 'appium-support';
+import { fs } from '@appium/support';
 import logger from './logger';
 import _ from 'lodash';
 
@@ -9,20 +9,31 @@ const hubUri = (config) => {
   return `${protocol}://${config.hubHost}:${config.hubPort}`;
 };
 
-async function registerNode (configFile, addr, port, basePath) {
-  let data;
-  try {
-    data = await fs.readFile(configFile, 'utf-8');
-  } catch (err) {
-    logger.error(`Unable to load node configuration file to register with grid: ${err.message}`);
-    return;
+/**
+ * Registers a new node with a selenium grid
+ * @param {string|object} data - Path or object representing selenium grid node config file. If a `string`, all subsequent arguments are required!
+ * @param {string} [addr] - Bind to this address
+ * @param {number} [port] - Bind to this port
+ * @param {string} [basePath] - Base path for the grid
+ */
+async function registerNode (data, addr, port, basePath) {
+  let configFilePath;
+  if (_.isString(data)) {
+    configFilePath = data;
+    try {
+      data = await fs.readFile(data, 'utf-8');
+    } catch (err) {
+      logger.error(`Unable to load node configuration file ${configFilePath} to register with grid: ${err.message}`);
+      return;
+    }
+    try {
+      data = JSON.parse(data);
+    } catch (err) {
+      logger.errorAndThrow(`Syntax error in node configuration file ${configFilePath}: ${err.message}`);
+      return;
+    }
   }
 
-  // Check presence of data before posting  it to the selenium grid
-  if (!data) {
-    logger.error('No data found in the node configuration file to send to the grid');
-    return;
-  }
   postRequest(data, addr, port, basePath);
 }
 
@@ -39,15 +50,7 @@ async function registerToGrid (postOptions, configHolder) {
   }
 }
 
-function postRequest (data, addr, port, basePath) {
-  // parse json to get hub host and port
-  let configHolder;
-  try {
-    configHolder = JSON.parse(data);
-  } catch (err) {
-    logger.errorAndThrow(`Syntax error in node configuration file: ${err.message}`);
-  }
-
+function postRequest (configHolder, addr, port, basePath) {
   // Move Selenium 3 configuration properties to configuration object
   if (!_.has(configHolder, 'configuration')) {
     let configuration = {};

package/lib/logger.js

@@ -1,4 +1,4 @@
-import { logger } from 'appium-support';
+import { logger } from '@appium/support';
 
 
 let log = logger.getLogger('Appium');

package/lib/logsink.js

@@ -1,7 +1,6 @@
 import npmlog from 'npmlog';
 import { createLogger, format, transports } from 'winston';
-import { fs, logger } from 'appium-support';
-import dateformat from 'dateformat';
+import { fs, logger } from '@appium/support';
 import _ from 'lodash';
 
 
@@ -36,16 +35,20 @@ const npmToWinstonLevels = {
 };
 
 let log = null;
-let timeZone = null;
+let useLocalTimeZone = false;
 
 // add the timestamp in the correct format to the log info object
 const timestampFormat = format.timestamp({
   format () {
     let date = new Date();
-    if (!timeZone) {
-      date = new Date(date.valueOf() + date.getTimezoneOffset() * 60000);
+    if (useLocalTimeZone) {
+      date = new Date(date.valueOf() - date.getTimezoneOffset() * 60000);
     }
-    return dateformat(date, 'yyyy-mm-dd HH:MM:ss:l');
+    // '2012-11-04T14:51:06.157Z' -> '2012-11-04 14:51:06:157'
+    return date.toISOString()
+      .replace(/[TZ]/g, ' ')
+      .replace(/\./g, ':')
+      .trim();
   },
 });
 
@@ -63,6 +66,8 @@ const stripColorFormat = format(function stripColor (info) {
 
 function createConsoleTransport (args, logLvl) {
   return new (transports.Console)({
+    // `name` is unsupported per winston's type declarations
+    // @ts-expect-error
     name: 'console',
     handleExceptions: true,
     exitOnError: false,
@@ -89,6 +94,7 @@ function createConsoleTransport (args, logLvl) {
 
 function createFileTransport (args, logLvl) {
   return new (transports.File)({
+    // @ts-expect-error
     name: 'file',
     filename: args.logFile,
     maxFiles: 1,
@@ -117,6 +123,7 @@ function createHttpTransport (args, logLvl) {
   }
 
   return new (transports.Http)({
+    // @ts-expect-error
     name: 'http',
     host,
     port,
@@ -182,7 +189,7 @@ async function createTransports (args) {
 
 async function init (args) {
   // set de facto param passed to timestamp function
-  timeZone = args.localTimezone;
+  useLocalTimeZone = args.localTimezone;
 
   // clean up in case we have initiated before since npmlog is a global object
   clear();

package/lib/main.js

@@ -1,42 +1,45 @@
 #!/usr/bin/env node
-// transpile:main
 
-import { init as logsinkInit } from './logsink';
-import logger from './logger'; // logger needs to remain first of imports
-import _ from 'lodash';
-import { server as baseServer, routeConfiguringFunction as makeRouter } from 'appium-base-driver';
+
+import { init as logsinkInit } from './logsink'; // this import needs to come first since it sets up global npmlog
+import logger from './logger'; // logger needs to remain second
+// @ts-ignore
+import { routeConfiguringFunction as makeRouter, server as baseServer } from '@appium/base-driver';
+import { logger as logFactory, util, env } from '@appium/support';
 import { asyncify } from 'asyncbox';
-import { default as getParser, getDefaultServerArgs } from './cli/parser';
-import { USE_ALL_PLUGINS } from './cli/args';
-import { logger as logFactory, util } from 'appium-support';
-import {
-  showConfig, checkNodeOk, validateServerArgs,
-  warnNodeDeprecations, validateTmpDir, getNonDefaultArgs,
-  getGitRev, APPIUM_VER
-} from './config';
-import DriverConfig from './driver-config';
-import PluginConfig from './plugin-config';
-import { DRIVER_TYPE, PLUGIN_TYPE } from './extension-config';
-import { runExtensionCommand } from './cli/extension';
+import _ from 'lodash';
 import { AppiumDriver } from './appium';
+import { runExtensionCommand } from './cli/extension';
+import { getParser } from './cli/parser';
+import { APPIUM_VER, checkNodeOk, getGitRev, getNonDefaultServerArgs, showConfig, showBuildInfo, validateTmpDir, warnNodeDeprecations } from './config';
+import { readConfigFile } from './config-file';
+import { loadExtensions, getActivePlugins, getActiveDrivers } from './extension';
+import { DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND } from './constants';
 import registerNode from './grid-register';
-import { inspectObject } from './utils';
+import { getDefaultsForSchema, validate } from './schema/schema';
+import { inspect } from './utils';
 
+const {resolveAppiumHome} = env;
 
-async function preflightChecks ({parser, args, driverConfig, pluginConfig, throwInsteadOfExit = false}) {
+/**
+ *
+ * @param {ParsedArgs} args
+ * @param {boolean} [throwInsteadOfExit]
+ */
+async function preflightChecks (args, throwInsteadOfExit = false) {
   try {
     checkNodeOk();
     if (args.longStacktrace) {
       require('longjohn').async_trace_limit = -1;
     }
-    if (args.showConfig) {
-      await showConfig();
+    if (args.showBuildInfo) {
+      await showBuildInfo();
       process.exit(0);
     }
     warnNodeDeprecations();
-    validateServerArgs(parser, args);
-    await driverConfig.read();
-    await pluginConfig.read();
+
+    validate(args);
+
     if (args.tmpDir) {
       await validateTmpDir(args.tmpDir);
     }
@@ -50,18 +53,24 @@ async function preflightChecks ({parser, args, driverConfig, pluginConfig, throw
   }
 }
 
+/**
+ * @param {Partial<ParsedArgs>} args
+ */
 function logNonDefaultArgsWarning (args) {
   logger.info('Non-default server args:');
-  inspectObject(args);
+  inspect(args);
 }
 
 function logDefaultCapabilitiesWarning (caps) {
   logger.info('Default capabilities, which will be added to each request ' +
               'unless overridden by desired capabilities:');
-  inspectObject(caps);
+  inspect(caps);
 }
 
-async function logStartupInfo (parser, args) {
+/**
+ * @param {ParsedArgs} args
+ */
+async function logStartupInfo (args) {
   let welcome = `Welcome to Appium v${APPIUM_VER}`;
   let appiumRev = await getGitRev();
   if (appiumRev) {
@@ -69,7 +78,7 @@ async function logStartupInfo (parser, args) {
   }
   logger.info(welcome);
 
-  let showArgs = getNonDefaultArgs(parser, args);
+  let showArgs = getNonDefaultServerArgs(args);
   if (_.size(showArgs)) {
     logNonDefaultArgsWarning(showArgs);
   }
@@ -83,20 +92,74 @@ async function logStartupInfo (parser, args) {
   // }
 }
 
+/**
+ * Logs the address and port the server is listening on
+ * @param {string} address - Address
+ * @param {number} port - Port
+ * @returns {void}
+ */
 function logServerPort (address, port) {
   let logMessage = `Appium REST http interface listener started on ` +
                    `${address}:${port}`;
   logger.info(logMessage);
 }
 
-async function main (args = null) {
-  let parser = getParser();
+/**
+ * Gets a list of `updateServer` functions from all extensions
+ * @param {DriverClass[]} driverClasses
+ * @param {PluginClass[]} pluginClasses
+ * @returns {import('@appium/base-driver/lib/basedriver/driver').UpdateServerCallback[]}
+ */
+function getServerUpdaters (driverClasses, pluginClasses) {
+  return _.compact(_.map([...driverClasses, ...pluginClasses], 'updateServer'));
+}
+
+/**
+ * Makes a big `MethodMap` from all the little `MethodMap`s in the extensions
+ * @param {DriverClass[]} driverClasses
+ * @param {PluginClass[]} pluginClasses
+ * @returns {import('@appium/types').MethodMap}
+ */
+function getExtraMethodMap (driverClasses, pluginClasses) {
+  return [...driverClasses, ...pluginClasses].reduce(
+    (map, klass) => ({...map, ...klass.newMethodMap}),
+    {}
+  );
+}
+
+/**
+ * Initializes Appium, but does not start the server.
+ *
+ * Use this to get at the configuration schema.
+ *
+ * If `args` contains a non-empty `subcommand` which is not `server`, this function will return an empty object.
+ *
+ * @param {PartialArgs} [args] - Partial args (progammatic usage only)
+ * @returns {Promise<ServerInitResult | ExtCommandInitResult>}
+ * @example
+ * import {init, getSchema} from 'appium';
+ * const options = {}; // config object
+ * await init(options);
+ * const schema = getSchema(); // entire config schema including plugins and drivers
+ */
+async function init (args) {
+  const appiumHome = args?.appiumHome ?? await resolveAppiumHome();
+
+  const {driverConfig, pluginConfig} = await loadExtensions(appiumHome);
+
+  const parser = getParser();
   let throwInsteadOfExit = false;
+  /** @type {ParsedArgs} */
+  let preConfigParsedArgs;
+  /** @type {ParsedArgs} */
+  let parsedArgs;
+  /**
+   * This is a definition (instead of declaration) because TS can't figure out
+   * the value will be defined when it's used.
+   * @type {ReturnType<getDefaultsForSchema>}
+   */
+  let defaults = {};
   if (args) {
-    // a containing package passed in their own args, let's fill them out
-    // with defaults
-    args = Object.assign({}, getDefaultServerArgs(), args);
-
     // if we have a containing package instead of running as a CLI process,
     // that package might not appreciate us calling 'process.exit' willy-
     // nilly, so give it the option to have us throw instead of exit
@@ -105,80 +168,134 @@ async function main (args = null) {
       // but remove it since it's not a real server arg per se
       delete args.throwInsteadOfExit;
     }
+    preConfigParsedArgs = /** @type {ParsedArgs} */({...args, subcommand: args.subcommand ?? SERVER_SUBCOMMAND});
   } else {
     // otherwise parse from CLI
-    args = parser.parseArgs();
+    preConfigParsedArgs = parser.parseArgs();
+  }
+
+  const configResult = await readConfigFile(preConfigParsedArgs.configFile);
+
+  if (!_.isEmpty(configResult.errors)) {
+    throw new Error(`Errors in config file ${configResult.filepath}:\n ${configResult.reason ?? configResult.errors}`);
   }
-  await logsinkInit(args);
+
+  // merge config and apply defaults.
+  // the order of precendece is:
+  // 1. command line args
+  // 2. config file
+  // 3. defaults from config file.
+  if (preConfigParsedArgs.subcommand === SERVER_SUBCOMMAND) {
+    defaults = getDefaultsForSchema(false);
+
+    parsedArgs = _.defaultsDeep(
+      preConfigParsedArgs,
+      configResult.config?.server,
+      defaults
+    );
+
+    if (preConfigParsedArgs.showConfig) {
+      showConfig(getNonDefaultServerArgs(preConfigParsedArgs), configResult, defaults, parsedArgs);
+      return {};
+    }
+
+  } else {
+    parsedArgs = preConfigParsedArgs;
+  }
+
+  await logsinkInit(parsedArgs);
 
   // if the user has requested the 'driver' CLI, don't run the normal server,
   // but instead pass control to the driver CLI
-  if (args.subcommand === DRIVER_TYPE || args.subcommand === PLUGIN_TYPE) {
-    await runExtensionCommand(args, args.subcommand);
-    process.exit();
+  if (parsedArgs.subcommand === DRIVER_TYPE) {
+    await runExtensionCommand(parsedArgs, driverConfig);
+    return {};
+  }
+  if (parsedArgs.subcommand === PLUGIN_TYPE) {
+    await runExtensionCommand(parsedArgs, pluginConfig);
+    return {};
   }
 
-  if (args.logFilters) {
-    const {issues, rules} = await logFactory.loadSecureValuesPreprocessingRules(args.logFilters);
+  if (parsedArgs.logFilters) {
+    const {issues, rules} = await logFactory.loadSecureValuesPreprocessingRules(parsedArgs.logFilters);
     if (!_.isEmpty(issues)) {
-      throw new Error(`The log filtering rules config '${args.logFilters}' has issues: ` +
+      throw new Error(`The log filtering rules config '${parsedArgs.logFilters}' has issues: ` +
         JSON.stringify(issues, null, 2));
     }
     if (_.isEmpty(rules)) {
-      logger.warn(`Found no log filtering rules in '${args.logFilters}'. Is that expected?`);
+      logger.warn(`Found no log filtering rules in '${parsedArgs.logFilters}'. Is that expected?`);
     } else {
-      logger.info(`Loaded ${util.pluralize('filtering rule', rules.length, true)} from '${args.logFilters}'`);
+      logger.info(`Loaded ${util.pluralize('filtering rule', rules.length, true)} from '${parsedArgs.logFilters}'`);
     }
   }
 
-  let appiumDriver = new AppiumDriver(args);
-  const driverConfig = new DriverConfig(args.appiumHome);
-  const pluginConfig = new PluginConfig(args.appiumHome);
+  const appiumDriver = new AppiumDriver(parsedArgs);
+  // set the config on the umbrella driver so it can match drivers to caps
   appiumDriver.driverConfig = driverConfig;
-  await preflightChecks({parser, args, driverConfig, pluginConfig, throwInsteadOfExit});
-  await logStartupInfo(parser, args);
+  await preflightChecks(parsedArgs, throwInsteadOfExit);
+
+  return /** @type {ServerInitResult} */({appiumDriver, parsedArgs, driverConfig, pluginConfig});
+}
+
+/**
+ * Initializes Appium's config.  Starts server if appropriate and resolves the
+ * server instance if so; otherwise resolves w/ `undefined`.
+ * @param {PartialArgs} [args] - Arguments from CLI or otherwise
+ * @returns {Promise<import('http').Server|undefined>}
+ */
+async function main (args) {
+  const {appiumDriver, parsedArgs, pluginConfig, driverConfig} = /** @type {ServerInitResult} */(await init(args));
+
+  if (!appiumDriver || !parsedArgs || !pluginConfig || !driverConfig) {
+    // if this branch is taken, we've run a different subcommand, so there's nothing
+    // left to do here.
+    return;
+  }
+
+  const pluginClasses = getActivePlugins(pluginConfig, parsedArgs.usePlugins);
+  // set the active plugins on the umbrella driver so it can use them for commands
+  appiumDriver.pluginClasses = pluginClasses;
+
+  await logStartupInfo(parsedArgs);
   let routeConfiguringFunction = makeRouter(appiumDriver);
 
-  // find any plugin name which has been installed, and which has been requested for activation by
-  // using the --plugins flag, and turn each one into an instantiated plugin object, so we can send
-  // them as objects to the server init. we also want to send/assign them to the umbrella driver so
-  // it can use them to wrap command execution
-  const plugins = Object.keys(pluginConfig.installedExtensions).filter((pluginName) =>
-    _.includes(args.plugins, pluginName) ||
-    (args.plugins.length === 1 && args.plugins[0] === USE_ALL_PLUGINS)
-  ).map((pluginName) => {
-    try {
-      const PluginClass = pluginConfig.require(pluginName);
-      return new PluginClass(pluginName);
-    } catch (err) {
-      logger.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;
+  const driverClasses = getActiveDrivers(driverConfig, parsedArgs.useDrivers);
+  const serverUpdaters = getServerUpdaters(driverClasses, pluginClasses);
+  const extraMethodMap = getExtraMethodMap(driverClasses, pluginClasses);
 
-  let server = await baseServer({
+  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 baseServer(serverOpts);
+  } catch (err) {
+    logger.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.debug(err.stack);
+    return process.exit(1);
+  }
+
+  if (parsedArgs.allowCors) {
     logger.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 {
-    // TODO prelaunch if args.launch is set
-    // TODO: startAlertSocket(server, appiumServer);
-
     // configure as node on grid, if necessary
-    if (args.nodeconfig !== null) {
-      await registerNode(args.nodeconfig, args.address, args.port, args.basePath);
+    // falsy values should not cause this to run
+    if (parsedArgs.nodeconfig) {
+      await registerNode(parsedArgs.nodeconfig, parsedArgs.address, parsedArgs.port, parsedArgs.basePath);
     }
   } catch (err) {
     await server.close();
@@ -202,15 +319,48 @@ 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;
 }
 
+// NOTE: this is here for backwards compat for any scripts referencing `main.js` directly
+// (more specifically, `build/lib/main.js`)
+// the executable is now `../index.js`, so that module will typically be `require.main`.
 if (require.main === module) {
   asyncify(main);
 }
 
-export { main };
+// everything below here is intended to be a public API.
+export { readConfigFile } from './config-file';
+export { finalizeSchema, getSchema, validate } from './schema/schema';
+export { main, init, resolveAppiumHome };
+
+/**
+ * @typedef {import('../types/cli').ParsedArgs} ParsedArgs
+ */
+
+/**
+ * @typedef {import('../types/cli').PartialArgs} PartialArgs
+ * @typedef {import('../types').DriverType} DriverType
+ * @typedef {import('../types').PluginType} PluginType
+ * @typedef {import('../types/extension').DriverClass} DriverClass
+ * @typedef {import('../types/extension').PluginClass} PluginClass
+ */
+
+/**
+ * Literally an empty object
+ * @typedef { {} } ExtCommandInitResult
+ */
+
+/**
+ * @typedef ServerInitData
+ * @property {AppiumDriver} appiumDriver - The Appium driver
+ * @property {ParsedArgs} parsedArgs - The parsed arguments
+ */
+
+/**
+ * @typedef {ServerInitData & import('./extension').ExtensionConfigs} ServerInitResult
+ */