appium 2.0.0-beta.30 → 2.0.0-beta.35

package/lib/cli/plugin-command.js

@@ -1,14 +1,16 @@
 import _ from 'lodash';
 import ExtensionCommand from './extension-command';
-import { KNOWN_PLUGINS } from '../constants';
+import {KNOWN_PLUGINS} from '../constants';
 
 const REQ_PLUGIN_FIELDS = ['pluginName', 'mainClass'];
 
+/**
+ * @extends {ExtensionCommand<PluginType>}
+ */
 export default class PluginCommand extends ExtensionCommand {
-
   /**
    *
-   * @param {PluginCommandOptions} opts
+   * @param {import('./extension-command').ExtensionCommandOptions<PluginType>} opts
    */
   constructor ({config, json}) {
     super({config, json});
@@ -16,41 +18,54 @@ export default class PluginCommand extends ExtensionCommand {
   }
 
   async install ({plugin, installType, packageName}) {
-    return await super._install({ext: plugin, installType, packageName});
+    return await super._install({
+      installSpec: plugin,
+      installType,
+      packageName,
+    });
   }
 
   async uninstall ({plugin}) {
-    return await super._uninstall({ext: plugin});
+    return await super._uninstall({installSpec: plugin});
   }
 
   async update ({plugin, unsafe}) {
-    return await super._update({ext: plugin, unsafe});
+    return await super._update({installSpec: plugin, unsafe});
   }
 
   async run ({plugin, scriptName}) {
-    return await super._run({ext: plugin, scriptName});
+    return await super._run({installSpec: plugin, scriptName});
   }
 
   getPostInstallText ({extName, extData}) {
     return `Plugin ${extName}@${extData.version} successfully installed`.green;
   }
 
-  validateExtensionFields (appiumPkgData) {
-    const missingFields = REQ_PLUGIN_FIELDS.reduce((acc, field) => (
-      appiumPkgData[field] ? acc : [...acc, field]
-    ), []);
+  /**
+   * Validates fields in `appium` field of `driverMetadata`
+   *
+   * For any `package.json` fields which a driver requires, validate the type of
+   * those fields on the `package.json` data, throwing an error if anything is
+   * amiss.
+   * @param {import('appium/types').ExtMetadata<PluginType>} pluginMetadata
+   * @param {string} installSpec
+   * @returns {void}
+   */
+  validateExtensionFields (pluginMetadata, installSpec) {
+    const missingFields = REQ_PLUGIN_FIELDS.reduce(
+      (acc, field) => (pluginMetadata[field] ? acc : [...acc, field]),
+      []
+    );
 
     if (!_.isEmpty(missingFields)) {
-      throw new Error(`Installed plugin did not expose correct fields for compability ` +
-                      `with Appium. Missing fields: ${JSON.stringify(missingFields)}`);
+      throw new Error(
+        `Installed plugin "${installSpec}" did not expose correct fields for compability ` +
+          `with Appium. Missing fields: ${JSON.stringify(missingFields)}`
+      );
     }
-
   }
-
 }
 
 /**
- * @typedef PluginCommandOptions
- * @property {import('../extension/extension-config').ExtensionConfig<import('../extension/manifest').PluginType>} config
- * @property {boolean} json
+ * @typedef {import('appium/types').PluginType} PluginType
  */

package/lib/config.js

@@ -160,14 +160,14 @@ async function showBuildInfo () {
 
 /**
  * Returns k/v pairs of server arguments which are _not_ the defaults.
- * @param {ParsedArgs} parsedArgs
- * @returns {Partial<ParsedArgs>}
+ * @param {Args} parsedArgs
+ * @returns {Args}
  */
 function getNonDefaultServerArgs (parsedArgs) {
   /**
    * Flattens parsed args into a single level object for comparison with
    * flattened defaults across server args and extension args.
-   * @param {ParsedArgs} args
+   * @param {Args} args
    * @returns {Record<string, { value: any, argSpec: ArgSpec }>}
    */
   const flatten = (args) => {
@@ -237,7 +237,7 @@ function getNonDefaultServerArgs (parsedArgs) {
   return _.reduce(
     _.pickBy(args, (__, key) => isNotDefault(key)),
     // explodes the flattened object back into nested one
-    (acc, {value, argSpec}) => _.set(acc, argSpec.dest, value), /** @type {Partial<ParsedArgs>} */({})
+    (acc, {value, argSpec}) => _.set(acc, argSpec.dest, value), /** @type {Args} */({})
   );
 }
 
@@ -306,7 +306,8 @@ export {
 };
 
 /**
- * @typedef {import('../types/cli').ParsedArgs} ParsedArgs
+ * @typedef {import('../types').ParsedArgs} ParsedArgs
+ * @typedef {import('../types').Args} Args
  * @typedef {import('./schema/arg-spec').ArgSpec} ArgSpec
  */
 

package/lib/extension/manifest.js

@@ -1,5 +1,3 @@
-/// <reference path="../../types/appium-manifest.d.ts" />
-
 /**
  * Module containing {@link Manifest} which handles reading & writing of extension config files.
  */

package/lib/main.js

@@ -54,13 +54,16 @@ async function preflightChecks (args, throwInsteadOfExit = false) {
 }
 
 /**
- * @param {Partial<ParsedArgs>} args
+ * @param {Args} args
  */
 function logNonDefaultArgsWarning (args) {
   logger.info('Non-default server args:');
   inspect(args);
 }
 
+/**
+ * @param {Args['defaultCapabilities']} caps
+ */
 function logDefaultCapabilitiesWarning (caps) {
   logger.info('Default capabilities, which will be added to each request ' +
               'unless overridden by desired capabilities:');
@@ -122,11 +125,20 @@ function getServerUpdaters (driverClasses, pluginClasses) {
  */
 function getExtraMethodMap (driverClasses, pluginClasses) {
   return [...driverClasses, ...pluginClasses].reduce(
-    (map, klass) => ({...map, ...klass.newMethodMap}),
+    (map, klass) => ({...map, .../** @type {DriverClass} */(klass).newMethodMap ?? {}}),
     {}
   );
 }
 
+/**
+ * @template [T=WithServerSubcommand]
+ * @param {Args<T>} args
+ * @returns {args is Args<WithServerSubcommand>}
+ */
+function areServerCommandArgs (args) {
+  return args.subcommand === SERVER_SUBCOMMAND;
+}
+
 /**
  * Initializes Appium, but does not start the server.
  *
@@ -134,7 +146,8 @@ function getExtraMethodMap (driverClasses, pluginClasses) {
  *
  * 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)
+ * @template [T=WithServerSubcommand]
+ * @param {Args<T>} [args] - Partial args (progammatic usage only)
  * @returns {Promise<ServerInitResult | ExtCommandInitResult>}
  * @example
  * import {init, getSchema} from 'appium';
@@ -149,16 +162,9 @@ async function init (args) {
 
   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 = {};
+  /** @type {Args<T>} */
+  let preConfigArgs;
+
   if (args) {
     // if we have a containing package instead of running as a CLI process,
     // that package might not appreciate us calling 'process.exit' willy-
@@ -168,13 +174,13 @@ async function init (args) {
       // 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});
+    preConfigArgs = {...args, subcommand: args.subcommand ?? SERVER_SUBCOMMAND};
   } else {
     // otherwise parse from CLI
-    preConfigParsedArgs = parser.parseArgs();
+    preConfigArgs = /** @type {Args<T>} */(parser.parseArgs());
   }
 
-  const configResult = await readConfigFile(preConfigParsedArgs.configFile);
+  const configResult = await readConfigFile(preConfigArgs.configFile);
 
   if (!_.isEmpty(configResult.errors)) {
     throw new Error(`Errors in config file ${configResult.filepath}:\n ${configResult.reason ?? configResult.errors}`);
@@ -185,63 +191,65 @@ async function init (args) {
   // 1. command line args
   // 2. config file
   // 3. defaults from config file.
-  if (preConfigParsedArgs.subcommand === SERVER_SUBCOMMAND) {
-    defaults = getDefaultsForSchema(false);
+  if (!areServerCommandArgs(preConfigArgs)) {
 
-    parsedArgs = _.defaultsDeep(
-      preConfigParsedArgs,
+    // if the user has requested the 'driver' CLI, don't run the normal server,
+    // but instead pass control to the driver CLI
+    if (preConfigArgs.subcommand === DRIVER_TYPE) {
+      await runExtensionCommand(preConfigArgs, driverConfig);
+      return {};
+    }
+    if (preConfigArgs.subcommand === PLUGIN_TYPE) {
+      await runExtensionCommand(preConfigArgs, pluginConfig);
+      return {};
+    }
+    /* istanbul ignore next */
+    return {}; // should never happen
+  } else {
+    const defaults = getDefaultsForSchema(false);
+
+    /** @type {ParsedArgs} */
+    const serverArgs = _.defaultsDeep(
+      preConfigArgs,
       configResult.config?.server,
       defaults
     );
 
-    if (preConfigParsedArgs.showConfig) {
-      showConfig(getNonDefaultServerArgs(preConfigParsedArgs), configResult, defaults, parsedArgs);
+    if (preConfigArgs.showConfig) {
+      showConfig(getNonDefaultServerArgs(preConfigArgs), configResult, defaults, serverArgs);
       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 (parsedArgs.subcommand === DRIVER_TYPE) {
-    await runExtensionCommand(parsedArgs, driverConfig);
-    return {};
-  }
-  if (parsedArgs.subcommand === PLUGIN_TYPE) {
-    await runExtensionCommand(parsedArgs, pluginConfig);
-    return {};
-  }
+    await logsinkInit(serverArgs);
 
-  if (parsedArgs.logFilters) {
-    const {issues, rules} = await logFactory.loadSecureValuesPreprocessingRules(parsedArgs.logFilters);
-    if (!_.isEmpty(issues)) {
-      throw new Error(`The log filtering rules config '${parsedArgs.logFilters}' has issues: ` +
+    if (serverArgs.logFilters) {
+      const {issues, rules} = await logFactory.loadSecureValuesPreprocessingRules(serverArgs.logFilters);
+      if (!_.isEmpty(issues)) {
+        throw new Error(`The log filtering rules config '${serverArgs.logFilters}' has issues: ` +
         JSON.stringify(issues, null, 2));
+      }
+      if (_.isEmpty(rules)) {
+        logger.warn(`Found no log filtering rules in '${serverArgs.logFilters}'. Is that expected?`);
+      } else {
+        logger.info(`Loaded ${util.pluralize('filtering rule', rules.length, true)} from '${serverArgs.logFilters}'`);
+      }
     }
-    if (_.isEmpty(rules)) {
-      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 '${parsedArgs.logFilters}'`);
-    }
-  }
 
-  const appiumDriver = new AppiumDriver(parsedArgs);
-  // set the config on the umbrella driver so it can match drivers to caps
-  appiumDriver.driverConfig = driverConfig;
-  await preflightChecks(parsedArgs, throwInsteadOfExit);
+    const appiumDriver = new AppiumDriver(serverArgs);
+    // set the config on the umbrella driver so it can match drivers to caps
+    appiumDriver.driverConfig = driverConfig;
+    await preflightChecks(serverArgs, throwInsteadOfExit);
 
-  return /** @type {ServerInitResult} */({appiumDriver, parsedArgs, driverConfig, pluginConfig});
+    return /** @type {ServerInitResult} */({appiumDriver, parsedArgs: serverArgs, 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>}
+ * @template [T=WithServerSubcommand]
+ * @param {Args<T>} [args] - Arguments from CLI or otherwise
+ * @returns {Promise<import('@appium/types').AppiumServer|undefined>}
  */
 async function main (args) {
   const {appiumDriver, parsedArgs, pluginConfig, driverConfig} = /** @type {ServerInitResult} */(await init(args));
@@ -339,15 +347,11 @@ 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
+ * @typedef {import('../types').DriverClass} DriverClass
+ * @typedef {import('../types').PluginClass} PluginClass
+ * @typedef {import('../types').WithServerSubcommand} WithServerSubcommand
  */
 
 /**
@@ -358,9 +362,20 @@ export { main, init, resolveAppiumHome };
 /**
  * @typedef ServerInitData
  * @property {AppiumDriver} appiumDriver - The Appium driver
- * @property {ParsedArgs} parsedArgs - The parsed arguments
+ * @property {import('../types').ParsedArgs} parsedArgs - The parsed arguments
  */
 
 /**
  * @typedef {ServerInitData & import('./extension').ExtensionConfigs} ServerInitResult
  */
+
+/**
+ * @template [T=WithServerSubcommand]
+ * @typedef {import('../types').Args<T>} Args
+ */
+
+/**
+ * @template [T=WithServerSubcommand]
+ * @typedef {import('../types').ParsedArgs<T>} ParsedArgs
+ */
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium",
-  "version": "2.0.0-beta.30",
+  "version": "2.0.0-beta.35",
   "description": "Automation for Apps.",
   "keywords": [
     "automation",
@@ -40,18 +40,24 @@
     "build": "babel lib --root-mode=upward --out-dir=build/lib",
     "dev": "npm run build -- --watch",
     "fix": "npm run lint -- --fix",
-    "generate-docs": "node ./scripts/parse-yml-commands.js",
+    "build:docs": "node docs/scripts/build-docs.js",
+    "build:docs:assets": "node docs/scripts/copy-assets.js",
+    "dev:docs": "npm run build:docs:assets && npm run dev:docs:en",
+    "dev:docs:en": "mkdocs serve -f ./docs/mkdocs-en.yml",
+    "dev:docs:ja": "mkdocs serve -f ./docs/mkdocs-ja.yml",
+    "publish:docs": "APPIUM_DOCS_PUBLISH=1 npm run build:docs",
     "postinstall": "node ./scripts/postinstall.js",
     "lint": "eslint -c ../../.eslintrc --ignore-path ../../.eslintignore .",
     "test": "npm run test:unit",
-    "test:e2e": "mocha --require ../../test/setup-babel.js --timeout 20s --slow 10s \"./test/e2e/**/*.spec.js\"",
-    "test:unit": "mocha --require ../../test/setup-babel.js \"./test/unit/**/*.spec.js\""
+    "test:e2e": "mocha --timeout 30s --slow 15s \"./test/e2e/**/*.spec.js\"",
+    "test:unit": "mocha \"./test/unit/**/*.spec.js\""
   },
   "dependencies": {
-    "@appium/base-driver": "^8.4.2",
-    "@appium/base-plugin": "1.8.1",
-    "@appium/schema": "^0.0.2",
-    "@appium/support": "^2.57.1",
+    "@appium/base-driver": "^8.5.3",
+    "@appium/base-plugin": "^1.8.5",
+    "@appium/docutils": "^0.0.4",
+    "@appium/schema": "^0.0.5",
+    "@appium/support": "^2.58.0",
     "@babel/runtime": "7.17.9",
     "@sidvind/better-ajv-errors": "1.1.1",
     "ajv": "8.11.0",
@@ -59,22 +65,22 @@
     "argparse": "2.0.1",
     "async-lock": "1.3.1",
     "asyncbox": "2.9.2",
-    "axios": "0.26.1",
+    "axios": "0.27.2",
     "bluebird": "3.7.2",
     "find-up": "5.0.0",
     "lilconfig": "2.0.5",
     "lodash": "4.17.21",
     "longjohn": "0.2.12",
-    "npmlog": "6.0.1",
+    "npmlog": "6.0.2",
     "ora": "5.4.1",
     "package-changed": "1.9.0",
     "resolve-from": "5.0.0",
-    "semver": "7.3.6",
+    "semver": "7.3.7",
     "source-map-support": "0.5.21",
     "teen_process": "1.16.0",
     "winston": "3.7.2",
     "word-wrap": "1.2.3",
-    "yaml": "1.10.2"
+    "yaml": "2.0.1"
   },
   "engines": {
     "node": ">=12",
@@ -84,6 +90,6 @@
     "access": "public",
     "tag": "next"
   },
-  "types": "./build/lib/index.d.ts",
-  "gitHead": "319f7289e7019efaeac1271936b2d991041a02c2"
+  "types": "./build/lib/main.d.ts",
+  "gitHead": "59dd30ba20d04a068d7b710671f273bc3a2298b7"
 }

package/types/{appium-manifest.d.ts → appium-manifest.ts}

@@ -28,7 +28,7 @@ export type ExtManifest<ExtType extends ExtensionType> = Omit<
   InternalMetadata &
   CommonMetadata; // XXX: ExtMetadata should be a union with CommonMetadata. why is this needed?
 
-type WithSchemaManifest = {
+export type WithSchemaManifest = {
   schema: SchemaMetadata;
 };
 

package/types/{cli.d.ts → cli.ts}

@@ -1,5 +1,5 @@
-import { DriverOpts } from '@appium/types';
-import {
+import {ServerArgs} from '@appium/types';
+import type {
   DRIVER_TYPE as DRIVER_SUBCOMMAND,
   EXT_SUBCOMMAND_INSTALL,
   EXT_SUBCOMMAND_LIST,
@@ -10,17 +10,21 @@ import {
   SERVER_SUBCOMMAND,
 } from '../lib/constants';
 
+export type ServerSubcommand = typeof SERVER_SUBCOMMAND;
+export type DriverSubcommand = typeof DRIVER_SUBCOMMAND;
+export type PluginSubcommand = typeof PLUGIN_SUBCOMMAND;
+
 /**
  * Possible subcommands for the `appium` CLI.
  */
-type CliSubcommand =
-  | typeof SERVER_SUBCOMMAND
-  | typeof DRIVER_SUBCOMMAND
-  | typeof PLUGIN_SUBCOMMAND;
+export type CliSubcommand =
+  | ServerSubcommand
+  | DriverSubcommand
+  | PluginSubcommand;
 
 /**
- * Possible subcommands of {@link DRIVER_SUBCOMMAND} or
- * {@link PLUGIN_SUBCOMMAND}.
+ * Possible subcommands of {@linkcode DriverSubcommand} or
+ * {@linkcode PluginSubcommand}.
  */
 export type CliExtensionSubcommand =
   | typeof EXT_SUBCOMMAND_INSTALL
@@ -33,7 +37,12 @@ export type CliExtensionSubcommand =
  * Random stuff that may appear in the parsed args which has no equivalent in a
  * config file.
  */
-interface MoreArgs {
+export interface MoreArgs {
+  /**
+   * Possible subcommands. If empty, defaults to {@linkcode ServerSubcommand}.
+   */
+  subcommand?: CliSubcommand;
+
   /**
    * Path to config file, if any. Does not make sense for this to be allowed in a config file!
    */
@@ -53,7 +62,7 @@ interface MoreArgs {
 /**
  * These arguments are _not_ supported by the CLI, but only via programmatic usage / tests.
  */
-interface ProgrammaticArgs {
+export interface ProgrammaticArgs {
   /**
    * If `true`, throw on error instead of exit.
    */
@@ -85,9 +94,9 @@ interface ProgrammaticArgs {
 }
 
 /**
- * These are args that Appium assigns while parsing the args.
+ * These are args which the user will specify if using an extension command
  */
-interface InternalArgs {
+export interface ExtArgs extends WithExtSubcommand {
   /**
    * Subcommands of `driver` subcommand
    */
@@ -97,32 +106,42 @@ interface InternalArgs {
    * Subcommands of `plugin` subcommand
    */
   pluginCommand?: CliExtensionSubcommand;
+}
 
-  /**
-   * Possible subcommands
-   */
-  subcommand: CliSubcommand;
+/**
+ * Args having the `server` subcommand
+ */
+export interface WithServerSubcommand {
+  subcommand?: ServerSubcommand;
 }
 
 /**
- * The same as {@link ParsedArgs} but with a nullable `subcommand`.
- * This is _not_ the same as `Partial<ParsedArgs>`.
+ * Args having the `driver` or `plugin` subcommand
  */
-export type PartialArgs = DriverOpts &
-  MoreArgs &
-  ProgrammaticArgs &
-  Partial<InternalArgs>;
+export interface WithExtSubcommand {
+  subcommand: DriverSubcommand | PluginSubcommand;
+}
 
 /**
- * The Appium configuration as a flattened object, parsed via CLI args _and_ any
- * CLI args unsupported by the config file.
- * @todo Does not make any assumptions about property names derived from
- * extensions.
+ * Some generic bits of arguments; should not be used outside this declaration
  */
-export type ParsedArgs = DriverOpts &
-  MoreArgs &
+type CommonArgs<SArgs, T = WithServerSubcommand> = MoreArgs &
   ProgrammaticArgs &
-  InternalArgs;
+  (T extends WithServerSubcommand
+    ? SArgs
+    : T extends WithExtSubcommand
+    ? ExtArgs
+    : never);
+
+/**
+ * Fully-parsed arguments, containing defaults, computed args, and config file values.
+ */
+export type ParsedArgs<T = WithServerSubcommand> = CommonArgs<ServerArgs, T>;
+
+/**
+ * Partial arguments, as supplied by a user. _May_ have defaults applied; _may_ contain config values; _may_ contain computed args.
+ */
+export type Args<T = WithServerSubcommand> = CommonArgs<Partial<ServerArgs>, T>;
 
 /**
  * Shown by `appium --build-info`

package/types/{extension.d.ts → extension.ts}

@@ -1,4 +1,4 @@
-import { BaseDriverBase } from '@appium/base-driver/lib/basedriver/driver';
+import type { BaseDriverBase } from '@appium/base-driver/lib/basedriver/driver';
 import { Class, Driver, ExternalDriver } from '@appium/types';
 import { DriverType, ExtensionType, PluginType } from '.';
 
@@ -8,7 +8,7 @@ export type DriverClass = BaseDriverBase<ExternalDriver,
 /**
  * Additional static props for external driver classes
  */
-interface ExternalDriverStatic {
+export interface ExternalDriverStatic {
   driverName: string;
 }
 
@@ -20,7 +20,7 @@ export type PluginClass = Class<PluginProto, ExternalPluginStatic>;
 /**
  * Static props for plugin classes
  */
-interface ExternalPluginStatic {
+export interface ExternalPluginStatic {
   pluginName: string;
 }
 
@@ -28,7 +28,7 @@ interface ExternalPluginStatic {
  * A plugin must have this shape.
  * @todo Use base plugin instead of this
  */
-interface PluginProto {
+export interface PluginProto {
   /**
    * I'm not sure why `plugin.name` is required, but it is.
    */

package/types/{external-manifest.d.ts → external-manifest.ts}

@@ -2,8 +2,8 @@
  * These types describe information about external extensions and the contents of their `package.json` files
  */
 
-import { SchemaObject } from 'ajv';
-import { PackageJson, SetRequired } from 'type-fest';
+import type { SchemaObject } from 'ajv';
+import type { PackageJson, SetRequired } from 'type-fest';
 import { DriverType, ExtensionType, PluginType } from './index';
 
 /**

package/types/{index.d.ts → index.ts}

@@ -5,3 +5,10 @@ export * from './cli';
 export type DriverType = 'driver';
 export type PluginType = 'plugin';
 export type ExtensionType = DriverType | PluginType;
+
+/**
+ * Known environment variables concerning Appium
+ */
+export interface AppiumEnv extends NodeJS.ProcessEnv {
+  APPIUM_HOME?: string;
+}