appium 2.0.0-beta.6 → 2.0.0-beta.60

package/build/lib/appium.js

@@ -1,459 +1,698 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.AppiumDriver = void 0;
-
-require("source-map-support/register");
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-var _logger = _interopRequireDefault(require("./logger"));
-
-var _config = require("./config");
-
-var _drivers = require("./drivers");
-
-var _appiumBaseDriver = require("appium-base-driver");
-
-var _bluebird = _interopRequireDefault(require("bluebird"));
-
-var _asyncLock = _interopRequireDefault(require("async-lock"));
-
-var _utils = require("./utils");
-
-var _appiumSupport = require("appium-support");
-
-const desiredCapabilityConstraints = {
-  automationName: {
-    presence: true,
-    isString: true
-  },
-  platformName: {
-    presence: true,
-    isString: true
-  }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-const sessionsListGuard = new _asyncLock.default();
-const pendingDriversGuard = new _asyncLock.default();
-
-class AppiumDriver extends _appiumBaseDriver.BaseDriver {
-  constructor(args) {
-    if (args.tmpDir) {
-      process.env.APPIUM_TMP_DIR = args.tmpDir;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppiumDriver = exports.NoDriverProxyCommandError = void 0;
+/* eslint-disable no-unused-vars */
+const lodash_1 = __importDefault(require("lodash"));
+const config_1 = require("./config");
+const base_driver_1 = require("@appium/base-driver");
+const async_lock_1 = __importDefault(require("async-lock"));
+const utils_1 = require("./utils");
+const support_1 = require("@appium/support");
+const schema_1 = require("./schema");
+const constants_1 = require("./constants");
+const desiredCapabilityConstraints = /** @type {const} */ ({
+    automationName: {
+        presence: true,
+        isString: true,
+    },
+    platformName: {
+        presence: true,
+        isString: true,
+    },
+});
+const sessionsListGuard = new async_lock_1.default();
+const pendingDriversGuard = new async_lock_1.default();
+/**
+ * @extends {DriverCore<AppiumDriverConstraints>}
+ */
+class AppiumDriver extends base_driver_1.DriverCore {
+    /**
+     * @param {import('@appium/types').DriverOpts<AppiumDriverConstraints>} opts
+     */
+    constructor(opts) {
+        // It is necessary to set `--tmp` here since it should be set to
+        // process.env.APPIUM_TMP_DIR once at an initial point in the Appium lifecycle.
+        // The process argument will be referenced by BaseDriver.
+        // Please call @appium/support.tempDir module to apply this benefit.
+        if (opts.tmpDir) {
+            process.env.APPIUM_TMP_DIR = opts.tmpDir;
+        }
+        super(opts);
+        this.args = { ...opts };
+        this.sessions = {};
+        this.pendingDrivers = {};
+        this.newCommandTimeoutMs = 0;
+        this.pluginClasses = new Map();
+        this.sessionPlugins = {};
+        this.sessionlessPlugins = [];
+        this.desiredCapConstraints = desiredCapabilityConstraints;
+        // allow this to happen in the background, so no `await`
+        (async () => {
+            try {
+                await (0, config_1.updateBuildInfo)();
+            }
+            catch (e) {
+                // make sure we catch any possible errors to avoid unhandled rejections
+                this.log.debug(`Cannot fetch Appium build info: ${e.message}`);
+            }
+        })();
     }
-
-    super(args);
-    this.desiredCapConstraints = desiredCapabilityConstraints;
-    this.newCommandTimeoutMs = 0;
-    this.args = Object.assign({}, args);
-    this.sessions = {};
-    this.pendingDrivers = {};
-    this.plugins = [];
-    (0, _config.updateBuildInfo)();
-  }
-
-  get isCommandsQueueEnabled() {
-    return false;
-  }
-
-  sessionExists(sessionId) {
-    const dstSession = this.sessions[sessionId];
-    return dstSession && dstSession.sessionId !== null;
-  }
-
-  driverForSession(sessionId) {
-    return this.sessions[sessionId];
-  }
-
-  async getStatus() {
-    return {
-      build: _lodash.default.clone((0, _config.getBuildInfo)())
-    };
-  }
-
-  async getSessions() {
-    const sessions = await sessionsListGuard.acquire(AppiumDriver.name, () => this.sessions);
-    return _lodash.default.toPairs(sessions).map(([id, driver]) => ({
-      id,
-      capabilities: driver.caps
-    }));
-  }
-
-  printNewSessionAnnouncement(driverName, driverVersion) {
-    const introString = driverVersion ? `Appium v${_config.APPIUM_VER} creating new ${driverName} (v${driverVersion}) session` : `Appium v${_config.APPIUM_VER} creating new ${driverName} session`;
-
-    _logger.default.info(introString);
-  }
-
-  _findMatchingDriver(...args) {
-    return (0, _drivers.findMatchingDriver)(...args);
-  }
-
-  async createSession(jsonwpCaps, reqCaps, w3cCapabilities) {
-    const defaultCapabilities = _lodash.default.cloneDeep(this.args.defaultCapabilities);
-
-    const defaultSettings = (0, _utils.pullSettings)(defaultCapabilities);
-    jsonwpCaps = _lodash.default.cloneDeep(jsonwpCaps);
-    const jwpSettings = Object.assign({}, defaultSettings, (0, _utils.pullSettings)(jsonwpCaps));
-    w3cCapabilities = _lodash.default.cloneDeep(w3cCapabilities);
-    const w3cSettings = Object.assign({}, jwpSettings);
-    Object.assign(w3cSettings, (0, _utils.pullSettings)((w3cCapabilities || {}).alwaysMatch || {}));
-
-    for (const firstMatchEntry of (w3cCapabilities || {}).firstMatch || []) {
-      Object.assign(w3cSettings, (0, _utils.pullSettings)(firstMatchEntry));
+    /**
+     * Retrieves logger instance for the current umbrella driver instance
+     */
+    get log() {
+        if (!this._log) {
+            const instanceName = `${this.constructor.name}@${support_1.node.getObjectId(this).substring(0, 4)}`;
+            this._log = support_1.logger.getLogger(instanceName);
+        }
+        return this._log;
     }
-
-    let protocol;
-    let innerSessionId, dCaps;
-
-    try {
-      const parsedCaps = (0, _utils.parseCapsForInnerDriver)(jsonwpCaps, w3cCapabilities, this.desiredCapConstraints, defaultCapabilities);
-      const {
-        desiredCaps,
-        processedJsonwpCapabilities,
-        processedW3CCapabilities,
-        error
-      } = parsedCaps;
-      protocol = parsedCaps.protocol;
-
-      if (error) {
-        throw error;
-      }
-
-      const {
-        driver: InnerDriver,
-        version: driverVersion
-      } = this._findMatchingDriver(this.driverConfig, desiredCaps);
-
-      this.printNewSessionAnnouncement(InnerDriver.name, driverVersion);
-
-      if (this.args.sessionOverride) {
-        await this.deleteAllSessions();
-      }
-
-      let runningDriversData, otherPendingDriversData;
-      const d = new InnerDriver(this.args);
-
-      if (this.args.relaxedSecurityEnabled) {
-        _logger.default.info(`Applying relaxed security to '${InnerDriver.name}' as per ` + `server command line argument. All insecure features will be ` + `enabled unless explicitly disabled by --deny-insecure`);
-
-        d.relaxedSecurityEnabled = true;
-      }
-
-      if (!_lodash.default.isEmpty(this.args.denyInsecure)) {
-        _logger.default.info('Explicitly preventing use of insecure features:');
-
-        this.args.denyInsecure.map(a => _logger.default.info(`    ${a}`));
-        d.denyInsecure = this.args.denyInsecure;
-      }
-
-      if (!_lodash.default.isEmpty(this.args.allowInsecure)) {
-        _logger.default.info('Explicitly enabling use of insecure features:');
-
-        this.args.allowInsecure.map(a => _logger.default.info(`    ${a}`));
-        d.allowInsecure = this.args.allowInsecure;
-      }
-
-      d.server = this.server;
-
-      try {
-        runningDriversData = await this.curSessionDataForDriver(InnerDriver);
-      } catch (e) {
-        throw new _appiumBaseDriver.errors.SessionNotCreatedError(e.message);
-      }
-
-      await pendingDriversGuard.acquire(AppiumDriver.name, () => {
-        this.pendingDrivers[InnerDriver.name] = this.pendingDrivers[InnerDriver.name] || [];
-        otherPendingDriversData = this.pendingDrivers[InnerDriver.name].map(drv => drv.driverData);
-        this.pendingDrivers[InnerDriver.name].push(d);
-      });
-
-      try {
-        [innerSessionId, dCaps] = await d.createSession(processedJsonwpCapabilities, reqCaps, processedW3CCapabilities, [...runningDriversData, ...otherPendingDriversData]);
-        protocol = d.protocol;
-        await sessionsListGuard.acquire(AppiumDriver.name, () => {
-          this.sessions[innerSessionId] = d;
-        });
-      } finally {
-        await pendingDriversGuard.acquire(AppiumDriver.name, () => {
-          _lodash.default.pull(this.pendingDrivers[InnerDriver.name], d);
-        });
-      }
-
-      this.attachUnexpectedShutdownHandler(d, innerSessionId);
-
-      _logger.default.info(`New ${InnerDriver.name} session created successfully, session ` + `${innerSessionId} added to master session list`);
-
-      d.startNewCommandTimeout();
-
-      if (d.isW3CProtocol() && !_lodash.default.isEmpty(w3cSettings)) {
-        _logger.default.info(`Applying the initial values to Appium settings parsed from W3C caps: ` + JSON.stringify(w3cSettings));
-
-        await d.updateSettings(w3cSettings);
-      } else if (d.isMjsonwpProtocol() && !_lodash.default.isEmpty(jwpSettings)) {
-        _logger.default.info(`Applying the initial values to Appium settings parsed from MJSONWP caps: ` + JSON.stringify(jwpSettings));
-
-        await d.updateSettings(jwpSettings);
-      }
-    } catch (error) {
-      return {
-        protocol,
-        error
-      };
+    /**
+     * Cancel commands queueing for the umbrella Appium driver
+     */
+    get isCommandsQueueEnabled() {
+        return false;
+    }
+    sessionExists(sessionId) {
+        const dstSession = this.sessions[sessionId];
+        return dstSession && dstSession.sessionId !== null;
+    }
+    driverForSession(sessionId) {
+        return this.sessions[sessionId];
+    }
+    // eslint-disable-next-line require-await
+    async getStatus() {
+        return {
+            build: lodash_1.default.clone((0, config_1.getBuildInfo)()),
+        };
+    }
+    async getSessions() {
+        return lodash_1.default.toPairs(this.sessions).map(([id, driver]) => ({
+            id,
+            capabilities: /** @type {import('@appium/types').DriverCaps} */ (driver.caps),
+        }));
+    }
+    printNewSessionAnnouncement(driverName, driverVersion, driverBaseVersion) {
+        this.log.info(driverVersion
+            ? `Appium v${config_1.APPIUM_VER} creating new ${driverName} (v${driverVersion}) session`
+            : `Appium v${config_1.APPIUM_VER} creating new ${driverName} session`);
+        this.log.info(`Checking BaseDriver versions for Appium and ${driverName}`);
+        this.log.info(AppiumDriver.baseVersion
+            ? `Appium's BaseDriver version is ${AppiumDriver.baseVersion}`
+            : `Could not determine Appium's BaseDriver version`);
+        this.log.info(driverBaseVersion
+            ? `${driverName}'s BaseDriver version is ${driverBaseVersion}`
+            : `Could not determine ${driverName}'s BaseDriver version`);
+    }
+    /**
+     * Retrieves all CLI arguments for a specific plugin.
+     * @param {string} extName - Plugin name
+     * @returns {StringRecord} Arguments object. If none, an empty object.
+     */
+    getCliArgsForPlugin(extName) {
+        return /** @type {StringRecord} */ (this.args.plugin?.[extName] ?? {});
+    }
+    /**
+     * Retrieves CLI args for a specific driver.
+     *
+     * _Any arg which is equal to its default value will not be present in the returned object._
+     *
+     * _Note that this behavior currently (May 18 2022) differs from how plugins are handled_ (see {@linkcode AppiumDriver.getCliArgsForPlugin}).
+     * @param {string} extName - Driver name
+     * @returns {StringRecord|undefined} Arguments object. If none, `undefined`
+     */
+    getCliArgsForDriver(extName) {
+        const allCliArgsForExt = /** @type {StringRecord|undefined} */ (this.args.driver?.[extName]);
+        if (!lodash_1.default.isEmpty(allCliArgsForExt)) {
+            const defaults = (0, schema_1.getDefaultsForExtension)(constants_1.DRIVER_TYPE, extName);
+            const cliArgs = lodash_1.default.isEmpty(defaults)
+                ? allCliArgsForExt
+                : lodash_1.default.omitBy(allCliArgsForExt, (value, key) => lodash_1.default.isEqual(defaults[key], value));
+            if (!lodash_1.default.isEmpty(cliArgs)) {
+                return cliArgs;
+            }
+        }
+    }
+    /**
+     * Create a new session
+     * @param {W3CAppiumDriverCaps} jsonwpCaps JSONWP formatted desired capabilities
+     * @param {W3CAppiumDriverCaps} [reqCaps] Required capabilities (JSONWP standard)
+     * @param {W3CAppiumDriverCaps} [w3cCapabilities] W3C capabilities
+     * @returns {Promise<SessionHandlerCreateResult>}
+     */
+    async createSession(jsonwpCaps, reqCaps, w3cCapabilities) {
+        const defaultCapabilities = lodash_1.default.cloneDeep(this.args.defaultCapabilities);
+        const defaultSettings = (0, utils_1.pullSettings)(defaultCapabilities);
+        jsonwpCaps = lodash_1.default.cloneDeep(jsonwpCaps);
+        const jwpSettings = { ...defaultSettings, ...(0, utils_1.pullSettings)(jsonwpCaps) };
+        w3cCapabilities = lodash_1.default.cloneDeep(w3cCapabilities);
+        // It is possible that the client only provides caps using JSONWP standard,
+        // although firstMatch/alwaysMatch properties are still present.
+        // In such case we assume the client understands W3C protocol and merge the given
+        // JSONWP caps to W3C caps
+        const w3cSettings = {
+            ...jwpSettings,
+            ...(0, utils_1.pullSettings)((w3cCapabilities ?? {}).alwaysMatch ?? {}),
+        };
+        for (const firstMatchEntry of (w3cCapabilities ?? {}).firstMatch ?? []) {
+            Object.assign(w3cSettings, (0, utils_1.pullSettings)(firstMatchEntry));
+        }
+        /** @type {string|undefined} */
+        let protocol;
+        let innerSessionId, dCaps;
+        try {
+            // Parse the caps into a format that the InnerDriver will accept
+            const parsedCaps = (0, utils_1.parseCapsForInnerDriver)(jsonwpCaps, (0, base_driver_1.promoteAppiumOptions)(/** @type {W3CAppiumDriverCaps} */ (w3cCapabilities)), this.desiredCapConstraints, defaultCapabilities ? (0, base_driver_1.promoteAppiumOptionsForObject)(defaultCapabilities) : undefined);
+            const { desiredCaps, processedJsonwpCapabilities, processedW3CCapabilities } = 
+            /** @type {import('./utils').ParsedDriverCaps<AppiumDriverConstraints>} */ (parsedCaps);
+            protocol = parsedCaps.protocol;
+            const error = /** @type {import('./utils').InvalidCaps<AppiumDriverConstraints>} */ (parsedCaps).error;
+            // If the parsing of the caps produced an error, throw it in here
+            if (error) {
+                throw error;
+            }
+            const { driver: InnerDriver, version: driverVersion, driverName, } = this.driverConfig.findMatchingDriver(desiredCaps);
+            this.printNewSessionAnnouncement(InnerDriver.name, driverVersion, InnerDriver.baseVersion);
+            if (this.args.sessionOverride) {
+                await this.deleteAllSessions();
+            }
+            /**
+             * @type {DriverData[]}
+             */
+            let runningDriversData = [];
+            /**
+             * @type {DriverData[]}
+             */
+            let otherPendingDriversData = [];
+            const driverInstance = /** @type {ExternalDriver} */ (new InnerDriver(this.args, true));
+            // We want to assign security values directly on the driver. The driver
+            // should not read security values from `this.opts` because those values
+            // could have been set by a malicious user via capabilities, whereas we
+            // want a guarantee the values were set by the appium server admin
+            if (this.args.relaxedSecurityEnabled) {
+                this.log.info(`Applying relaxed security to '${InnerDriver.name}' as per ` +
+                    `server command line argument. All insecure features will be ` +
+                    `enabled unless explicitly disabled by --deny-insecure`);
+                driverInstance.relaxedSecurityEnabled = true;
+            }
+            if (!lodash_1.default.isEmpty(this.args.denyInsecure)) {
+                this.log.info('Explicitly preventing use of insecure features:');
+                this.args.denyInsecure.map((a) => this.log.info(`    ${a}`));
+                driverInstance.denyInsecure = this.args.denyInsecure;
+            }
+            if (!lodash_1.default.isEmpty(this.args.allowInsecure)) {
+                this.log.info('Explicitly enabling use of insecure features:');
+                this.args.allowInsecure.map((a) => this.log.info(`    ${a}`));
+                driverInstance.allowInsecure = this.args.allowInsecure;
+            }
+            // Likewise, any driver-specific CLI args that were passed in should be assigned directly to
+            // the driver so that they cannot be mimicked by a malicious user sending in capabilities
+            const cliArgs = this.getCliArgsForDriver(driverName);
+            if (!lodash_1.default.isUndefined(cliArgs)) {
+                driverInstance.cliArgs = cliArgs;
+            }
+            // This assignment is required for correct web sockets functionality inside the driver
+            // Drivers/plugins might also want to know where they are hosted
+            // XXX: temporary hack to work around #16747
+            driverInstance.server = this.server;
+            driverInstance.serverHost = this.args.address;
+            driverInstance.serverPort = this.args.port;
+            driverInstance.serverPath = this.args.basePath;
+            try {
+                runningDriversData = (await this.curSessionDataForDriver(InnerDriver)) ?? [];
+            }
+            catch (e) {
+                throw new base_driver_1.errors.SessionNotCreatedError(e.message);
+            }
+            await pendingDriversGuard.acquire(AppiumDriver.name, () => {
+                this.pendingDrivers[InnerDriver.name] = this.pendingDrivers[InnerDriver.name] || [];
+                otherPendingDriversData = lodash_1.default.compact(this.pendingDrivers[InnerDriver.name].map((drv) => drv.driverData));
+                this.pendingDrivers[InnerDriver.name].push(driverInstance);
+            });
+            try {
+                [innerSessionId, dCaps] = await driverInstance.createSession(processedJsonwpCapabilities, reqCaps, processedW3CCapabilities, [...runningDriversData, ...otherPendingDriversData]);
+                protocol = driverInstance.protocol;
+                this.sessions[innerSessionId] = driverInstance;
+            }
+            finally {
+                await pendingDriversGuard.acquire(AppiumDriver.name, () => {
+                    lodash_1.default.pull(this.pendingDrivers[InnerDriver.name], driverInstance);
+                });
+            }
+            this.attachUnexpectedShutdownHandler(driverInstance, innerSessionId);
+            this.log.info(`New ${InnerDriver.name} session created successfully, session ` +
+                `${innerSessionId} added to master session list`);
+            // set the New Command Timeout for the inner driver
+            driverInstance.startNewCommandTimeout();
+            // apply initial values to Appium settings (if provided)
+            if (driverInstance.isW3CProtocol() && !lodash_1.default.isEmpty(w3cSettings)) {
+                this.log.info(`Applying the initial values to Appium settings parsed from W3C caps: ` +
+                    JSON.stringify(w3cSettings));
+                await driverInstance.updateSettings(w3cSettings);
+            }
+            else if (driverInstance.isMjsonwpProtocol() && !lodash_1.default.isEmpty(jwpSettings)) {
+                this.log.info(`Applying the initial values to Appium settings parsed from MJSONWP caps: ` +
+                    JSON.stringify(jwpSettings));
+                await driverInstance.updateSettings(jwpSettings);
+            }
+        }
+        catch (error) {
+            return {
+                protocol,
+                error,
+            };
+        }
+        return {
+            protocol,
+            value: [innerSessionId, dCaps, protocol],
+        };
+    }
+    /**
+     *
+     * @param {ExternalDriver} driver
+     * @param {string} innerSessionId
+     */
+    attachUnexpectedShutdownHandler(driver, innerSessionId) {
+        const onShutdown = (cause = new Error('Unknown error')) => {
+            this.log.warn(`Ending session, cause was '${cause.message}'`);
+            if (this.sessionPlugins[innerSessionId]) {
+                for (const plugin of this.sessionPlugins[innerSessionId]) {
+                    if (lodash_1.default.isFunction(plugin.onUnexpectedShutdown)) {
+                        this.log.debug(`Plugin ${plugin.name} defines an unexpected shutdown handler; calling it now`);
+                        try {
+                            plugin.onUnexpectedShutdown(driver, cause);
+                        }
+                        catch (e) {
+                            this.log.warn(`Got an error when running plugin ${plugin.name} shutdown handler: ${e}`);
+                        }
+                    }
+                    else {
+                        this.log.debug(`Plugin ${plugin.name} does not define an unexpected shutdown handler`);
+                    }
+                }
+            }
+            this.log.info(`Removing session '${innerSessionId}' from our master session list`);
+            delete this.sessions[innerSessionId];
+            delete this.sessionPlugins[innerSessionId];
+        };
+        if (lodash_1.default.isFunction(driver.onUnexpectedShutdown)) {
+            driver.onUnexpectedShutdown(onShutdown);
+        }
+        else {
+            this.log.warn(`Failed to attach the unexpected shutdown listener. ` +
+                `Is 'onUnexpectedShutdown' method available for '${driver.constructor.name}'?`);
+        }
+    }
+    /**
+     *
+     * @param {((...args: any[]) => any)|(new(...args: any[]) => any)} InnerDriver
+     * @returns {Promise<DriverData[]>}}
+     * @privateRemarks The _intent_ is that `InnerDriver` is the class of a driver, but it only really
+     * needs to be a function or constructor.
+     */
+    async curSessionDataForDriver(InnerDriver) {
+        const data = lodash_1.default.compact(lodash_1.default.values(this.sessions)
+            .filter((s) => s.constructor.name === InnerDriver.name)
+            .map((s) => s.driverData));
+        for (const datum of data) {
+            if (!datum) {
+                throw new Error(`Problem getting session data for driver type ` +
+                    `${InnerDriver.name}; does it implement 'get driverData'?`);
+            }
+        }
+        return data;
     }
-
-    return {
-      protocol,
-      value: [innerSessionId, dCaps, protocol]
-    };
-  }
-
-  attachUnexpectedShutdownHandler(driver, innerSessionId) {
-    const removeSessionFromMasterList = (cause = new Error('Unknown error')) => {
-      _logger.default.warn(`Closing session, cause was '${cause.message}'`);
-
-      _logger.default.info(`Removing session '${innerSessionId}' from our master session list`);
-
-      delete this.sessions[innerSessionId];
-    };
-
-    if (_lodash.default.isFunction((driver.onUnexpectedShutdown || {}).then)) {
-      driver.onUnexpectedShutdown.then(() => {
-        throw new Error('Unexpected shutdown');
-      }).catch(e => {
-        if (!(e instanceof _bluebird.default.CancellationError)) {
-          removeSessionFromMasterList(e);
+    /**
+     * @param {string} sessionId
+     */
+    async deleteSession(sessionId) {
+        let protocol;
+        try {
+            let otherSessionsData;
+            const dstSession = await sessionsListGuard.acquire(AppiumDriver.name, () => {
+                if (!this.sessions[sessionId]) {
+                    return;
+                }
+                const curConstructorName = this.sessions[sessionId].constructor.name;
+                otherSessionsData = lodash_1.default.toPairs(this.sessions)
+                    .filter(([key, value]) => value.constructor.name === curConstructorName && key !== sessionId)
+                    .map(([, value]) => value.driverData);
+                const dstSession = this.sessions[sessionId];
+                protocol = dstSession.protocol;
+                this.log.info(`Removing session ${sessionId} from our master session list`);
+                // regardless of whether the deleteSession completes successfully or not
+                // make the session unavailable, because who knows what state it might
+                // be in otherwise
+                delete this.sessions[sessionId];
+                delete this.sessionPlugins[sessionId];
+                return dstSession;
+            });
+            // this may not be correct, but if `dstSession` was falsy, the call to `deleteSession()` would
+            // throw anyway.
+            if (!dstSession) {
+                throw new Error('Session not found');
+            }
+            return {
+                protocol,
+                value: await dstSession.deleteSession(sessionId, otherSessionsData),
+            };
+        }
+        catch (e) {
+            this.log.error(`Had trouble ending session ${sessionId}: ${e.message}`);
+            return {
+                protocol,
+                error: e,
+            };
         }
-      });
-    } else if (_lodash.default.isFunction(driver.onUnexpectedShutdown)) {
-      driver.onUnexpectedShutdown(removeSessionFromMasterList);
-    } else {
-      _logger.default.warn(`Failed to attach the unexpected shutdown listener. ` + `Is 'onUnexpectedShutdown' method available for '${driver.constructor.name}'?`);
     }
-  }
-
-  async curSessionDataForDriver(InnerDriver) {
-    const sessions = await sessionsListGuard.acquire(AppiumDriver.name, () => this.sessions);
-
-    const data = _lodash.default.values(sessions).filter(s => s.constructor.name === InnerDriver.name).map(s => s.driverData);
-
-    for (let datum of data) {
-      if (!datum) {
-        throw new Error(`Problem getting session data for driver type ` + `${InnerDriver.name}; does it implement 'get ` + `driverData'?`);
-      }
+    async deleteAllSessions(opts = {}) {
+        const sessionsCount = lodash_1.default.size(this.sessions);
+        if (0 === sessionsCount) {
+            this.log.debug('There are no active sessions for cleanup');
+            return;
+        }
+        const { force = false, reason } = opts;
+        this.log.debug(`Cleaning up ${support_1.util.pluralize('active session', sessionsCount, true)}`);
+        const cleanupPromises = force
+            ? lodash_1.default.values(this.sessions).map((drv) => drv.startUnexpectedShutdown(reason && new Error(reason)))
+            : lodash_1.default.keys(this.sessions).map((id) => this.deleteSession(id));
+        for (const cleanupPromise of cleanupPromises) {
+            try {
+                await cleanupPromise;
+            }
+            catch (e) {
+                this.log.debug(e);
+            }
+        }
     }
-
-    return data;
-  }
-
-  async deleteSession(sessionId) {
-    let protocol;
-
-    try {
-      let otherSessionsData = null;
-      let dstSession = null;
-      await sessionsListGuard.acquire(AppiumDriver.name, () => {
-        if (!this.sessions[sessionId]) {
-          return;
+    /**
+     * Get the appropriate plugins for a session (or sessionless plugins)
+     *
+     * @param {?string} sessionId - the sessionId (or null) to use to find plugins
+     * @returns {Array} - array of plugin instances
+     */
+    pluginsForSession(sessionId = null) {
+        if (sessionId) {
+            if (!this.sessionPlugins[sessionId]) {
+                this.sessionPlugins[sessionId] = this.createPluginInstances();
+            }
+            return this.sessionPlugins[sessionId];
+        }
+        if (lodash_1.default.isEmpty(this.sessionlessPlugins)) {
+            this.sessionlessPlugins = this.createPluginInstances();
         }
-
-        const curConstructorName = this.sessions[sessionId].constructor.name;
-        otherSessionsData = _lodash.default.toPairs(this.sessions).filter(([key, value]) => value.constructor.name === curConstructorName && key !== sessionId).map(([, value]) => value.driverData);
-        dstSession = this.sessions[sessionId];
-        protocol = dstSession.protocol;
-
-        _logger.default.info(`Removing session ${sessionId} from our master session list`);
-
-        delete this.sessions[sessionId];
-      });
-      return {
-        protocol,
-        value: await dstSession.deleteSession(sessionId, otherSessionsData)
-      };
-    } catch (e) {
-      _logger.default.error(`Had trouble ending session ${sessionId}: ${e.message}`);
-
-      return {
-        protocol,
-        error: e
-      };
+        return this.sessionlessPlugins;
+    }
+    /**
+     * To get plugins for a command, we either get the plugin instances associated with the
+     * particular command's session, or in the case of sessionless plugins, pull from the set of
+     * plugin instances reserved for sessionless commands (and we lazily create plugin instances on
+     * first use)
+     *
+     * @param {string} cmd - the name of the command to find a plugin to handle
+     * @param {?string} sessionId - the particular session for which to find a plugin, or null if
+     * sessionless
+     */
+    pluginsToHandleCmd(cmd, sessionId = null) {
+        // to handle a given command, a plugin should either implement that command as a plugin
+        // instance method or it should implement a generic 'handle' method
+        return this.pluginsForSession(sessionId).filter((p) => lodash_1.default.isFunction(p[cmd]) || lodash_1.default.isFunction(p.handle));
     }
-  }
-
-  async deleteAllSessions(opts = {}) {
-    const sessionsCount = _lodash.default.size(this.sessions);
-
-    if (0 === sessionsCount) {
-      _logger.default.debug('There are no active sessions for cleanup');
-
-      return;
+    /**
+     * Creates instances of all of the enabled Plugin classes
+     * @returns {Plugin[]}
+     */
+    createPluginInstances() {
+        /** @type {Plugin[]} */
+        const pluginInstances = [];
+        for (const [PluginClass, name] of this.pluginClasses.entries()) {
+            const cliArgs = this.getCliArgsForPlugin(name);
+            const plugin = new PluginClass(name, cliArgs);
+            pluginInstances.push(plugin);
+        }
+        return pluginInstances;
+    }
+    /**
+     *
+     * @param {string} cmd
+     * @param  {...any} args
+     * @returns {Promise<{value: any, error?: Error, protocol: string} | import('type-fest').AsyncReturnType<ExternalDriver['executeCommand']>>}
+     */
+    async executeCommand(cmd, ...args) {
+        // We have basically three cases for how to handle commands:
+        // 1. handle getStatus (we do this as a special out of band case so it doesn't get added to an
+        //    execution queue, and can be called while e.g. createSession is in progress)
+        // 2. handle commands that this umbrella driver should handle, rather than the actual session
+        //    driver (for example, deleteSession, or other non-session commands)
+        // 3. handle session driver commands.
+        // The tricky part is that because we support command plugins, we need to wrap any of these
+        // cases with plugin handling.
+        const isGetStatus = cmd === base_driver_1.GET_STATUS_COMMAND;
+        const isUmbrellaCmd = isAppiumDriverCommand(cmd);
+        const isSessionCmd = (0, base_driver_1.isSessionCommand)(cmd);
+        // if a plugin override proxying for this command and that is why we are here instead of just
+        // letting the protocol proxy the command entirely, determine that, get the request object for
+        // use later on, then clean up the args
+        const reqForProxy = lodash_1.default.last(args)?.reqForProxy;
+        if (reqForProxy) {
+            args.pop();
+        }
+        // first do some error checking. If we're requesting a session command execution, then make
+        // sure that session actually exists on the session driver, and set the session driver itself
+        let sessionId = null;
+        let dstSession = null;
+        let protocol = null;
+        /** @type {this | ExternalDriver} */
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let driver = this;
+        if (isSessionCmd) {
+            sessionId = lodash_1.default.last(args);
+            dstSession = this.sessions[sessionId];
+            if (!dstSession) {
+                throw new Error(`The session with id '${sessionId}' does not exist`);
+            }
+            // now save the response protocol given that the session driver's protocol might differ
+            protocol = dstSession.protocol;
+            if (!isUmbrellaCmd) {
+                driver = dstSession;
+            }
+        }
+        // get any plugins which are registered as handling this command
+        const plugins = this.pluginsToHandleCmd(cmd, sessionId);
+        // now we define a 'cmdHandledBy' object which will keep track of which plugins have handled this
+        // command. we care about this because (a) multiple plugins can handle the same command, and
+        // (b) there's no guarantee that a plugin will actually call the next() method which runs the
+        // original command execution. This results in a situation where the command might be handled
+        // by some but not all plugins, or by plugin(s) but not by the default behavior. So start out
+        // this object declaring that the default handler has not been executed.
+        const cmdHandledBy = { default: false };
+        // now we define an async function which will be passed to plugins, and successively wrapped
+        // if there is more than one plugin that can handle the command. To start off with, the async
+        // function is defined as calling the default behavior, i.e., whichever of the 3 cases above is
+        // the appropriate one
+        const defaultBehavior = async () => {
+            // if we're running with plugins, make sure we log that the default behavior is actually
+            // happening so we can tell when the plugin call chain is unwrapping to the default behavior
+            // if that's what happens
+            plugins.length && this.log.info(`Executing default handling behavior for command '${cmd}'`);
+            // if we make it here, we know that the default behavior is handled
+            cmdHandledBy.default = true;
+            if (reqForProxy) {
+                // we would have proxied this command had a plugin not handled it, so the default behavior
+                // is to do the proxy and retrieve the result internally so it can be passed to the plugin
+                // in case it calls 'await next()'. This requires that the driver have defined
+                // 'proxyCommand' and not just 'proxyReqRes'.
+                if (!dstSession.proxyCommand) {
+                    throw new NoDriverProxyCommandError();
+                }
+                return await dstSession.proxyCommand(reqForProxy.originalUrl, reqForProxy.method, reqForProxy.body);
+            }
+            if (isGetStatus) {
+                return await this.getStatus();
+            }
+            if (isUmbrellaCmd) {
+                // some commands, like deleteSession, we want to make sure to handle on *this* driver,
+                // not the platform driver
+                return await base_driver_1.BaseDriver.prototype.executeCommand.call(this, cmd, ...args);
+            }
+            // here we know that we are executing a session command, and have a valid session driver
+            return await dstSession.executeCommand(cmd, ...args);
+        };
+        // now take our default behavior, wrap it with any number of plugin behaviors, and run it
+        const wrappedCmd = this.wrapCommandWithPlugins({
+            driver,
+            cmd,
+            args,
+            plugins,
+            cmdHandledBy,
+            next: defaultBehavior,
+        });
+        const res = await this.executeWrappedCommand({ wrappedCmd, protocol });
+        // if we had plugins, make sure to log out the helpful report about which plugins ended up
+        // handling the command and which didn't
+        this.logPluginHandlerReport(plugins, { cmd, cmdHandledBy });
+        // And finally, if the command was createSession, we want to migrate any plugins which were
+        // previously sessionless to use the new sessionId, so that plugins can share state between
+        // their createSession method and other instance methods
+        if (cmd === base_driver_1.CREATE_SESSION_COMMAND && this.sessionlessPlugins.length && !res.error) {
+            const sessionId = lodash_1.default.first(res.value);
+            this.log.info(`Promoting ${this.sessionlessPlugins.length} sessionless plugins to be attached ` +
+                `to session ID ${sessionId}`);
+            this.sessionPlugins[sessionId] = this.sessionlessPlugins;
+            this.sessionlessPlugins = [];
+        }
+        return res;
     }
-
-    const {
-      force = false,
-      reason
-    } = opts;
-
-    _logger.default.debug(`Cleaning up ${_appiumSupport.util.pluralize('active session', sessionsCount, true)}`);
-
-    const cleanupPromises = force ? _lodash.default.values(this.sessions).map(drv => drv.startUnexpectedShutdown(reason && new Error(reason))) : _lodash.default.keys(this.sessions).map(id => this.deleteSession(id));
-
-    for (const cleanupPromise of cleanupPromises) {
-      try {
-        await cleanupPromise;
-      } catch (e) {
-        _logger.default.debug(e);
-      }
+    wrapCommandWithPlugins({ driver, cmd, args, next, cmdHandledBy, plugins }) {
+        plugins.length &&
+            this.log.info(`Plugins which can handle cmd '${cmd}': ${plugins.map((p) => p.name)}`);
+        // now we can go through each plugin and wrap `next` around its own handler, passing the *old*
+        // next in so that it can call it if it wants to
+        for (const plugin of plugins) {
+            // need an IIFE here because we want the value of next that's passed to plugin.handle to be
+            // exactly the value of next here before reassignment; we don't want it to be lazily
+            // evaluated, otherwise we end up with infinite recursion of the last `next` to be defined.
+            cmdHandledBy[plugin.name] = false; // we see a new plugin, so add it to the 'cmdHandledBy' object
+            next = ((_next) => async () => {
+                this.log.info(`Plugin ${plugin.name} is now handling cmd '${cmd}'`);
+                cmdHandledBy[plugin.name] = true; // if we make it here, this plugin has attempted to handle cmd
+                // first attempt to handle the command via a command-specific handler on the plugin
+                if (plugin[cmd]) {
+                    return await plugin[cmd](_next, driver, ...args);
+                }
+                // otherwise, call the generic 'handle' method
+                return await plugin.handle(_next, driver, cmd, ...args);
+            })(next);
+        }
+        return next;
     }
-  }
-
-  pluginsToHandleCmd(cmd) {
-    return this.plugins.filter(p => p.commands === true || _lodash.default.isArray(p.commands) && _lodash.default.includes(p.commands, cmd));
-  }
-
-  async executeCommand(cmd, ...args) {
-    const isGetStatus = cmd === 'getStatus';
-    const isUmbrellaCmd = !isGetStatus && isAppiumDriverCommand(cmd);
-    const isSessionCmd = !isGetStatus && !isUmbrellaCmd;
-    const plugins = this.pluginsToHandleCmd(cmd);
-    let sessionId = null;
-    let dstSession = null;
-    let protocol = null;
-
-    if (isSessionCmd) {
-      sessionId = _lodash.default.last(args);
-      dstSession = await sessionsListGuard.acquire(AppiumDriver.name, () => this.sessions[sessionId]);
-
-      if (!dstSession) {
-        throw new Error(`The session with id '${sessionId}' does not exist`);
-      }
-
-      protocol = dstSession.protocol;
+    logPluginHandlerReport(plugins, { cmd, cmdHandledBy }) {
+        if (!plugins.length) {
+            return;
+        }
+        // at the end of the day, we have an object representing which plugins ended up getting
+        // their code run as part of handling this command. Because plugins can choose *not* to
+        // pass control to other plugins or to the default driver behavior, this is information
+        // which is probably useful to the user (especially in situations where plugins might not
+        // interact well together, and it would be hard to debug otherwise without this kind of
+        // message).
+        const didHandle = Object.keys(cmdHandledBy).filter((k) => cmdHandledBy[k]);
+        const didntHandle = Object.keys(cmdHandledBy).filter((k) => !cmdHandledBy[k]);
+        if (didntHandle.length > 0) {
+            this.log.info(`Command '${cmd}' was *not* handled by the following behaviours or plugins, even ` +
+                `though they were registered to handle it: ${JSON.stringify(didntHandle)}. The ` +
+                `command *was* handled by these: ${JSON.stringify(didHandle)}.`);
+        }
     }
-
-    const cmdHandledBy = {
-      default: false
-    };
-
-    const defaultBehavior = async () => {
-      plugins.length && _logger.default.info(`Executing default handling behavior for command '${cmd}'`);
-      cmdHandledBy.default = true;
-
-      if (isGetStatus) {
-        return await this.getStatus();
-      }
-
-      if (isUmbrellaCmd) {
-        return await super.executeCommand(cmd, ...args);
-      }
-
-      return await dstSession.executeCommand(cmd, ...args);
-    };
-
-    const wrappedCmd = this.wrapCommandWithPlugins({
-      cmd,
-      args,
-      plugins,
-      cmdHandledBy,
-      next: defaultBehavior
-    });
-    const res = await this.executeWrappedCommand({
-      wrappedCmd,
-      protocol
-    });
-    plugins.length && this.logPluginHandlerReport({
-      cmd,
-      cmdHandledBy
-    });
-    return res;
-  }
-
-  wrapCommandWithPlugins({
-    cmd,
-    args,
-    next,
-    cmdHandledBy,
-    plugins
-  }) {
-    plugins.length && _logger.default.info(`Plugins which can handle cmd '${cmd}': ${plugins.map(p => p.name)}`);
-
-    for (const plugin of plugins) {
-      cmdHandledBy[plugin.name] = false;
-
-      next = (_next => async () => {
-        _logger.default.info(`Plugin ${plugin.name} is now handling cmd '${cmd}'`);
-
-        cmdHandledBy[plugin.name] = true;
-        return await plugin.handle(_next, this, cmd, ...args);
-      })(next);
+    async executeWrappedCommand({ wrappedCmd, protocol }) {
+        let cmdRes, cmdErr, res = {};
+        try {
+            // At this point, `wrappedCmd` defines a whole sequence of plugin handlers, culminating in
+            // our default handler. Whatever it returns is what we're going to want to send back to the
+            // user.
+            cmdRes = await wrappedCmd();
+        }
+        catch (e) {
+            cmdErr = e;
+        }
+        // Sadly, we don't know exactly what kind of object will be returned. It will either be a bare
+        // object, or a protocol-aware object with protocol and error/value keys. So we need to sniff
+        // it and make sure we don't double-wrap it if it's the latter kind.
+        if (lodash_1.default.isPlainObject(cmdRes) && lodash_1.default.has(cmdRes, 'protocol')) {
+            res = cmdRes;
+        }
+        else {
+            res.value = cmdRes;
+            res.error = cmdErr;
+            res.protocol = protocol;
+        }
+        return res;
     }
-
-    return next;
-  }
-
-  logPluginHandlerReport({
-    cmd,
-    cmdHandledBy
-  }) {
-    const didHandle = Object.keys(cmdHandledBy).filter(k => cmdHandledBy[k]);
-    const didntHandle = Object.keys(cmdHandledBy).filter(k => !cmdHandledBy[k]);
-
-    if (didntHandle.length > 0) {
-      _logger.default.info(`Command '${cmd}' was not handled by the following beahviors or plugins, even ` + `though they were registered to handle it: ${JSON.stringify(didntHandle)}. The ` + `command *was* handled by these: ${JSON.stringify(didHandle)}.`);
+    proxyActive(sessionId) {
+        const dstSession = this.sessions[sessionId];
+        return dstSession && lodash_1.default.isFunction(dstSession.proxyActive) && dstSession.proxyActive(sessionId);
     }
-  }
-
-  async executeWrappedCommand({
-    wrappedCmd,
-    protocol
-  }) {
-    let cmdRes,
-        cmdErr,
-        res = {};
-
-    try {
-      cmdRes = await wrappedCmd();
-    } catch (e) {
-      cmdErr = e;
+    /**
+     *
+     * @param {string} sessionId
+     * @returns {import('@appium/types').RouteMatcher[]}
+     */
+    getProxyAvoidList(sessionId) {
+        const dstSession = this.sessions[sessionId];
+        return dstSession ? dstSession.getProxyAvoidList() : [];
     }
-
-    if (_lodash.default.isPlainObject(cmdRes) && _lodash.default.has(cmdRes, 'protocol')) {
-      res = cmdRes;
-    } else {
-      res.value = cmdRes;
-      res.error = cmdErr;
-      res.protocol = protocol;
+    canProxy(sessionId) {
+        const dstSession = this.sessions[sessionId];
+        return dstSession && dstSession.canProxy(sessionId);
     }
-
-    return res;
-  }
-
-  proxyActive(sessionId) {
-    const dstSession = this.sessions[sessionId];
-    return dstSession && _lodash.default.isFunction(dstSession.proxyActive) && dstSession.proxyActive(sessionId);
-  }
-
-  getProxyAvoidList(sessionId) {
-    const dstSession = this.sessions[sessionId];
-    return dstSession ? dstSession.getProxyAvoidList() : [];
-  }
-
-  canProxy(sessionId) {
-    const dstSession = this.sessions[sessionId];
-    return dstSession && dstSession.canProxy(sessionId);
-  }
-
 }
-
 exports.AppiumDriver = AppiumDriver;
-
+// help decide which commands should be proxied to sub-drivers and which
+// should be handled by this, our umbrella driver
 function isAppiumDriverCommand(cmd) {
-  return !(0, _appiumBaseDriver.isSessionCommand)(cmd) || cmd === 'deleteSession';
-}require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/appium.js"],"names":["desiredCapabilityConstraints","automationName","presence","isString","platformName","sessionsListGuard","AsyncLock","pendingDriversGuard","AppiumDriver","BaseDriver","constructor","args","tmpDir","process","env","APPIUM_TMP_DIR","desiredCapConstraints","newCommandTimeoutMs","Object","assign","sessions","pendingDrivers","plugins","isCommandsQueueEnabled","sessionExists","sessionId","dstSession","driverForSession","getStatus","build","_","clone","getSessions","acquire","name","toPairs","map","id","driver","capabilities","caps","printNewSessionAnnouncement","driverName","driverVersion","introString","APPIUM_VER","log","info","_findMatchingDriver","createSession","jsonwpCaps","reqCaps","w3cCapabilities","defaultCapabilities","cloneDeep","defaultSettings","jwpSettings","w3cSettings","alwaysMatch","firstMatchEntry","firstMatch","protocol","innerSessionId","dCaps","parsedCaps","desiredCaps","processedJsonwpCapabilities","processedW3CCapabilities","error","InnerDriver","version","driverConfig","sessionOverride","deleteAllSessions","runningDriversData","otherPendingDriversData","d","relaxedSecurityEnabled","isEmpty","denyInsecure","a","allowInsecure","server","curSessionDataForDriver","e","errors","SessionNotCreatedError","message","drv","driverData","push","pull","attachUnexpectedShutdownHandler","startNewCommandTimeout","isW3CProtocol","JSON","stringify","updateSettings","isMjsonwpProtocol","value","removeSessionFromMasterList","cause","Error","warn","isFunction","onUnexpectedShutdown","then","catch","B","CancellationError","data","values","filter","s","datum","deleteSession","otherSessionsData","curConstructorName","key","opts","sessionsCount","size","debug","force","reason","util","pluralize","cleanupPromises","startUnexpectedShutdown","keys","cleanupPromise","pluginsToHandleCmd","cmd","p","commands","isArray","includes","executeCommand","isGetStatus","isUmbrellaCmd","isAppiumDriverCommand","isSessionCmd","last","cmdHandledBy","default","defaultBehavior","length","wrappedCmd","wrapCommandWithPlugins","next","res","executeWrappedCommand","logPluginHandlerReport","plugin","_next","handle","didHandle","k","didntHandle","cmdRes","cmdErr","isPlainObject","has","proxyActive","getProxyAvoidList","canProxy"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport log from './logger';\nimport { getBuildInfo, updateBuildInfo, APPIUM_VER } from './config';\nimport { findMatchingDriver } from './drivers';\nimport { BaseDriver, errors, isSessionCommand } from 'appium-base-driver';\nimport B from 'bluebird';\nimport AsyncLock from 'async-lock';\nimport { parseCapsForInnerDriver, pullSettings } from './utils';\nimport { util } from 'appium-support';\n\nconst desiredCapabilityConstraints = {\n  automationName: {\n    presence: true,\n    isString: true,\n  },\n  platformName: {\n    presence: true,\n    isString: true,\n  },\n};\n\nconst sessionsListGuard = new AsyncLock();\nconst pendingDriversGuard = new AsyncLock();\n\nclass AppiumDriver extends BaseDriver {\n  constructor (args) {\n    // It is necessary to set `--tmp` here since it should be set to\n    // process.env.APPIUM_TMP_DIR once at an initial point in the Appium lifecycle.\n    // The process argument will be referenced by BaseDriver.\n    // Please call appium-support.tempDir module to apply this benefit.\n    if (args.tmpDir) {\n      process.env.APPIUM_TMP_DIR = args.tmpDir;\n    }\n\n    super(args);\n\n    this.desiredCapConstraints = desiredCapabilityConstraints;\n\n    // the main Appium Driver has no new command timeout\n    this.newCommandTimeoutMs = 0;\n\n    this.args = Object.assign({}, args);\n\n    // Access to sessions list must be guarded with a Semaphore, because\n    // it might be changed by other async calls at any time\n    // It is not recommended to access this property directly from the outside\n    this.sessions = {};\n\n    // Access to pending drivers list must be guarded with a Semaphore, because\n    // it might be changed by other async calls at any time\n    // It is not recommended to access this property directly from the outside\n    this.pendingDrivers = {};\n\n    this.plugins = [];\n\n    // allow this to happen in the background, so no `await`\n    updateBuildInfo();\n  }\n\n  /**\n   * Cancel commands queueing for the umbrella Appium driver\n   */\n  get isCommandsQueueEnabled () {\n    return false;\n  }\n\n  sessionExists (sessionId) {\n    const dstSession = this.sessions[sessionId];\n    return dstSession && dstSession.sessionId !== null;\n  }\n\n  driverForSession (sessionId) {\n    return this.sessions[sessionId];\n  }\n\n  async getStatus () { // eslint-disable-line require-await\n    return {\n      build: _.clone(getBuildInfo()),\n    };\n  }\n\n  async getSessions () {\n    const sessions = await sessionsListGuard.acquire(AppiumDriver.name, () => this.sessions);\n    return _.toPairs(sessions)\n      .map(([id, driver]) => ({id, capabilities: driver.caps}));\n  }\n\n  printNewSessionAnnouncement (driverName, driverVersion) {\n    const introString = driverVersion\n      ? `Appium v${APPIUM_VER} creating new ${driverName} (v${driverVersion}) session`\n      : `Appium v${APPIUM_VER} creating new ${driverName} session`;\n    log.info(introString);\n  }\n\n  /**\n   * This is just an alias for driver.js's method, which is necessary for\n   * mocking in the test suite\n   */\n  _findMatchingDriver (...args) {\n    return findMatchingDriver(...args);\n  }\n\n  /**\n   * Create a new session\n   * @param {Object} jsonwpCaps JSONWP formatted desired capabilities\n   * @param {Object} reqCaps Required capabilities (JSONWP standard)\n   * @param {Object} w3cCapabilities W3C capabilities\n   * @return {Array} Unique session ID and capabilities\n   */\n  async createSession (jsonwpCaps, reqCaps, w3cCapabilities) {\n    const defaultCapabilities = _.cloneDeep(this.args.defaultCapabilities);\n    const defaultSettings = pullSettings(defaultCapabilities);\n    jsonwpCaps = _.cloneDeep(jsonwpCaps);\n    const jwpSettings = Object.assign({}, defaultSettings, pullSettings(jsonwpCaps));\n    w3cCapabilities = _.cloneDeep(w3cCapabilities);\n    // It is possible that the client only provides caps using JSONWP standard,\n    // although firstMatch/alwaysMatch properties are still present.\n    // In such case we assume the client understands W3C protocol and merge the given\n    // JSONWP caps to W3C caps\n    const w3cSettings = Object.assign({}, jwpSettings);\n    Object.assign(w3cSettings, pullSettings((w3cCapabilities || {}).alwaysMatch || {}));\n    for (const firstMatchEntry of ((w3cCapabilities || {}).firstMatch || [])) {\n      Object.assign(w3cSettings, pullSettings(firstMatchEntry));\n    }\n\n    let protocol;\n    let innerSessionId, dCaps;\n    try {\n      // Parse the caps into a format that the InnerDriver will accept\n      const parsedCaps = parseCapsForInnerDriver(\n        jsonwpCaps,\n        w3cCapabilities,\n        this.desiredCapConstraints,\n        defaultCapabilities\n      );\n\n      const {desiredCaps, processedJsonwpCapabilities, processedW3CCapabilities, error} = parsedCaps;\n      protocol = parsedCaps.protocol;\n\n      // If the parsing of the caps produced an error, throw it in here\n      if (error) {\n        throw error;\n      }\n\n      const {\n        driver: InnerDriver,\n        version: driverVersion\n      } = this._findMatchingDriver(this.driverConfig, desiredCaps);\n      this.printNewSessionAnnouncement(InnerDriver.name, driverVersion);\n\n      if (this.args.sessionOverride) {\n        await this.deleteAllSessions();\n      }\n\n      let runningDriversData, otherPendingDriversData;\n      const d = new InnerDriver(this.args);\n\n      // We want to assign security values directly on the driver. The driver\n      // should not read security values from `this.opts` because those values\n      // could have been set by a malicious user via capabilities, whereas we\n      // want a guarantee the values were set by the appium server admin\n      if (this.args.relaxedSecurityEnabled) {\n        log.info(`Applying relaxed security to '${InnerDriver.name}' as per ` +\n                 `server command line argument. All insecure features will be ` +\n                 `enabled unless explicitly disabled by --deny-insecure`);\n        d.relaxedSecurityEnabled = true;\n      }\n\n      if (!_.isEmpty(this.args.denyInsecure)) {\n        log.info('Explicitly preventing use of insecure features:');\n        this.args.denyInsecure.map((a) => log.info(`    ${a}`));\n        d.denyInsecure = this.args.denyInsecure;\n      }\n\n      if (!_.isEmpty(this.args.allowInsecure)) {\n        log.info('Explicitly enabling use of insecure features:');\n        this.args.allowInsecure.map((a) => log.info(`    ${a}`));\n        d.allowInsecure = this.args.allowInsecure;\n      }\n\n      // This assignment is required for correct web sockets functionality inside the driver\n      d.server = this.server;\n      try {\n        runningDriversData = await this.curSessionDataForDriver(InnerDriver);\n      } catch (e) {\n        throw new errors.SessionNotCreatedError(e.message);\n      }\n      await pendingDriversGuard.acquire(AppiumDriver.name, () => {\n        this.pendingDrivers[InnerDriver.name] = this.pendingDrivers[InnerDriver.name] || [];\n        otherPendingDriversData = this.pendingDrivers[InnerDriver.name].map((drv) => drv.driverData);\n        this.pendingDrivers[InnerDriver.name].push(d);\n      });\n\n      try {\n        [innerSessionId, dCaps] = await d.createSession(\n          processedJsonwpCapabilities,\n          reqCaps,\n          processedW3CCapabilities,\n          [...runningDriversData, ...otherPendingDriversData]\n        );\n        protocol = d.protocol;\n        await sessionsListGuard.acquire(AppiumDriver.name, () => {\n          this.sessions[innerSessionId] = d;\n        });\n      } finally {\n        await pendingDriversGuard.acquire(AppiumDriver.name, () => {\n          _.pull(this.pendingDrivers[InnerDriver.name], d);\n        });\n      }\n\n      this.attachUnexpectedShutdownHandler(d, innerSessionId);\n\n      log.info(`New ${InnerDriver.name} session created successfully, session ` +\n              `${innerSessionId} added to master session list`);\n\n      // set the New Command Timeout for the inner driver\n      d.startNewCommandTimeout();\n\n      // apply initial values to Appium settings (if provided)\n      if (d.isW3CProtocol() && !_.isEmpty(w3cSettings)) {\n        log.info(`Applying the initial values to Appium settings parsed from W3C caps: ` +\n          JSON.stringify(w3cSettings));\n        await d.updateSettings(w3cSettings);\n      } else if (d.isMjsonwpProtocol() && !_.isEmpty(jwpSettings)) {\n        log.info(`Applying the initial values to Appium settings parsed from MJSONWP caps: ` +\n          JSON.stringify(jwpSettings));\n        await d.updateSettings(jwpSettings);\n      }\n    } catch (error) {\n      return {\n        protocol,\n        error,\n      };\n    }\n\n    return {\n      protocol,\n      value: [innerSessionId, dCaps, protocol]\n    };\n  }\n\n  attachUnexpectedShutdownHandler (driver, innerSessionId) {\n    const removeSessionFromMasterList = (cause = new Error('Unknown error')) => {\n      log.warn(`Closing session, cause was '${cause.message}'`);\n      log.info(`Removing session '${innerSessionId}' from our master session list`);\n      delete this.sessions[innerSessionId];\n    };\n\n    // eslint-disable-next-line promise/prefer-await-to-then\n    if (_.isFunction((driver.onUnexpectedShutdown || {}).then)) {\n      // TODO: Remove this block after all the drivers use base driver above v 5.0.0\n      // Remove the session on unexpected shutdown, so that we are in a position\n      // to open another session later on.\n      driver.onUnexpectedShutdown\n        // eslint-disable-next-line promise/prefer-await-to-then\n        .then(() => {\n          // if we get here, we've had an unexpected shutdown, so error\n          throw new Error('Unexpected shutdown');\n        })\n        .catch((e) => {\n          // if we cancelled the unexpected shutdown promise, that means we\n          // no longer care about it, and can safely ignore it\n          if (!(e instanceof B.CancellationError)) {\n            removeSessionFromMasterList(e);\n          }\n        }); // this is a cancellable promise\n    } else if (_.isFunction(driver.onUnexpectedShutdown)) {\n      // since base driver v 5.0.0\n      driver.onUnexpectedShutdown(removeSessionFromMasterList);\n    } else {\n      log.warn(`Failed to attach the unexpected shutdown listener. ` +\n        `Is 'onUnexpectedShutdown' method available for '${driver.constructor.name}'?`);\n    }\n  }\n\n  async curSessionDataForDriver (InnerDriver) {\n    const sessions = await sessionsListGuard.acquire(AppiumDriver.name, () => this.sessions);\n    const data = _.values(sessions)\n                   .filter((s) => s.constructor.name === InnerDriver.name)\n                   .map((s) => s.driverData);\n    for (let datum of data) {\n      if (!datum) {\n        throw new Error(`Problem getting session data for driver type ` +\n                        `${InnerDriver.name}; does it implement 'get ` +\n                        `driverData'?`);\n      }\n    }\n    return data;\n  }\n\n  async deleteSession (sessionId) {\n    let protocol;\n    try {\n      let otherSessionsData = null;\n      let dstSession = null;\n      await sessionsListGuard.acquire(AppiumDriver.name, () => {\n        if (!this.sessions[sessionId]) {\n          return;\n        }\n        const curConstructorName = this.sessions[sessionId].constructor.name;\n        otherSessionsData = _.toPairs(this.sessions)\n              .filter(([key, value]) => value.constructor.name === curConstructorName && key !== sessionId)\n              .map(([, value]) => value.driverData);\n        dstSession = this.sessions[sessionId];\n        protocol = dstSession.protocol;\n        log.info(`Removing session ${sessionId} from our master session list`);\n        // regardless of whether the deleteSession completes successfully or not\n        // make the session unavailable, because who knows what state it might\n        // be in otherwise\n        delete this.sessions[sessionId];\n      });\n      return {\n        protocol,\n        value: await dstSession.deleteSession(sessionId, otherSessionsData),\n      };\n    } catch (e) {\n      log.error(`Had trouble ending session ${sessionId}: ${e.message}`);\n      return {\n        protocol,\n        error: e,\n      };\n    }\n  }\n\n  async deleteAllSessions (opts = {}) {\n    const sessionsCount = _.size(this.sessions);\n    if (0 === sessionsCount) {\n      log.debug('There are no active sessions for cleanup');\n      return;\n    }\n\n    const {\n      force = false,\n      reason,\n    } = opts;\n    log.debug(`Cleaning up ${util.pluralize('active session', sessionsCount, true)}`);\n    const cleanupPromises = force\n      ? _.values(this.sessions).map((drv) => drv.startUnexpectedShutdown(reason && new Error(reason)))\n      : _.keys(this.sessions).map((id) => this.deleteSession(id));\n    for (const cleanupPromise of cleanupPromises) {\n      try {\n        await cleanupPromise;\n      } catch (e) {\n        log.debug(e);\n      }\n    }\n  }\n\n  pluginsToHandleCmd (cmd) {\n    return this.plugins.filter((p) =>\n      p.commands === true ||\n      (_.isArray(p.commands) && _.includes(p.commands, cmd))\n    );\n  }\n\n  async executeCommand (cmd, ...args) {\n    // We have basically three cases for how to handle commands:\n    // 1. handle getStatus (we do this as a special out of band case so it doesn't get added to an\n    //    execution queue, and can be called while e.g. createSession is in progress)\n    // 2. handle commands that this umbrella driver should handle, rather than the actual session\n    //    driver (for example, deleteSession, or other non-session commands)\n    // 3. handle session driver commands.\n    // The tricky part is that because we support command plugins, we need to wrap any of these\n    // cases with plugin handling.\n\n    const isGetStatus = cmd === 'getStatus';\n    const isUmbrellaCmd = !isGetStatus && isAppiumDriverCommand(cmd);\n    const isSessionCmd = !isGetStatus && !isUmbrellaCmd;\n\n    // get any plugins which are registered as handling this command\n    const plugins = this.pluginsToHandleCmd(cmd);\n\n    // first do some error checking. If we're requesting a session command execution, then make\n    // sure that session actually exists on the session driver, and set the session driver itself\n    let sessionId = null;\n    let dstSession = null;\n    let protocol = null;\n    if (isSessionCmd) {\n      sessionId = _.last(args);\n      dstSession = await sessionsListGuard.acquire(AppiumDriver.name, () => this.sessions[sessionId]);\n      if (!dstSession) {\n        throw new Error(`The session with id '${sessionId}' does not exist`);\n      }\n      // now save the response protocol given that the session driver's protocol might differ\n      protocol = dstSession.protocol;\n    }\n\n    // now we define a 'cmdHandledBy' object which will keep track of which plugins have handled this\n    // command. we care about this because (a) multiple plugins can handle the same command, and\n    // (b) there's no guarantee that a plugin will actually call the next() method which runs the\n    // original command execution. This results in a situation where the command might be handled\n    // by some but not all plugins, or by plugin(s) but not by the default behavior. So start out\n    // this object declaring that the default handler has not been executed.\n    const cmdHandledBy = {default: false};\n\n    // now we define an async function which will be passed to plugins, and successively wrapped\n    // if there is more than one plugin that can handle the command. To start off with, the async\n    // function is defined as calling the default behavior, i.e., whichever of the 3 cases above is\n    // the appropriate one\n    const defaultBehavior = async () => {\n      // if we're running with plugins, make sure we log that the default behavior is actually\n      // happening so we can tell when the plugin call chain is unwrapping to the default behavior\n      // if that's what happens\n      plugins.length && log.info(`Executing default handling behavior for command '${cmd}'`);\n\n      // if we make it here, we know that the default behavior is handled\n      cmdHandledBy.default = true;\n\n      if (isGetStatus) {\n        return await this.getStatus();\n      }\n\n      if (isUmbrellaCmd) {\n        // some commands, like deleteSession, we want to make sure to handle on *this* driver,\n        // not the platform driver\n        return await super.executeCommand(cmd, ...args);\n      }\n\n      // here we know that we are executing a session command, and have a valid session driver\n      return await dstSession.executeCommand(cmd, ...args);\n    };\n\n    // now take our default behavior, wrap it with any number of plugin behaviors, and run it\n    const wrappedCmd = this.wrapCommandWithPlugins({cmd, args, plugins, cmdHandledBy, next: defaultBehavior});\n    const res = await this.executeWrappedCommand({wrappedCmd, protocol});\n\n    // if we had plugins, make sure to log out the helpful report about which plugins ended up\n    // handling the command and which didn't\n    plugins.length && this.logPluginHandlerReport({cmd, cmdHandledBy});\n\n    return res;\n  }\n\n  wrapCommandWithPlugins ({cmd, args, next, cmdHandledBy, plugins}) {\n    plugins.length && log.info(`Plugins which can handle cmd '${cmd}': ${plugins.map((p) => p.name)}`);\n\n    // now we can go through each plugin and wrap `next` around its own handler, passing the *old*\n    // next in so that it can call it if it wants to\n    for (const plugin of plugins) {\n      // need an IIFE here because we want the value of next that's passed to plugin.handle to be\n      // exactly the value of next here before reassignment; we don't want it to be lazily\n      // evaluated, otherwise we end up with infinite recursion of the last `next` to be defined.\n      cmdHandledBy[plugin.name] = false; // we see a new plugin, so add it to the 'cmdHandledBy' object\n      next = ((_next) => async () => {\n        log.info(`Plugin ${plugin.name} is now handling cmd '${cmd}'`);\n        cmdHandledBy[plugin.name] = true; // if we make it here, this plugin has attempted to handle cmd\n        return await plugin.handle(_next, this, cmd, ...args);\n      })(next);\n    }\n\n    return next;\n  }\n\n  logPluginHandlerReport ({cmd, cmdHandledBy}) {\n    // at the end of the day, we have an object representing which plugins ended up getting\n    // their code run as part of handling this command. Because plugins can choose *not* to\n    // pass control to other plugins or to the default driver behavior, this is information\n    // which is probably useful to the user (especially in situations where plugins might not\n    // interact well together, and it would be hard to debug otherwise without this kind of\n    // message).\n    const didHandle = Object.keys(cmdHandledBy).filter((k) => cmdHandledBy[k]);\n    const didntHandle = Object.keys(cmdHandledBy).filter((k) => !cmdHandledBy[k]);\n    if (didntHandle.length > 0) {\n      log.info(`Command '${cmd}' was not handled by the following beahviors or plugins, even ` +\n               `though they were registered to handle it: ${JSON.stringify(didntHandle)}. The ` +\n               `command *was* handled by these: ${JSON.stringify(didHandle)}.`);\n    }\n  }\n\n  async executeWrappedCommand ({wrappedCmd, protocol}) {\n    let cmdRes, cmdErr, res = {};\n    try {\n      // At this point, `wrappedCmd` defines a whole sequence of plugin handlers, culminating in\n      // our default handler. Whatever it returns is what we're going to want to send back to the\n      // user.\n      cmdRes = await wrappedCmd();\n    } catch (e) {\n      cmdErr = e;\n    }\n\n    // Sadly, we don't know exactly what kind of object will be returned. It will either be a bare\n    // object, or a protocol-aware object with protocol and error/value keys. So we need to sniff\n    // it and make sure we don't double-wrap it if it's the latter kind.\n    if (_.isPlainObject(cmdRes) && _.has(cmdRes, 'protocol')) {\n      res = cmdRes;\n    } else {\n      res.value = cmdRes;\n      res.error = cmdErr;\n      res.protocol = protocol;\n    }\n    return res;\n  }\n\n\n  proxyActive (sessionId) {\n    const dstSession = this.sessions[sessionId];\n    return dstSession && _.isFunction(dstSession.proxyActive) && dstSession.proxyActive(sessionId);\n  }\n\n  getProxyAvoidList (sessionId) {\n    const dstSession = this.sessions[sessionId];\n    return dstSession ? dstSession.getProxyAvoidList() : [];\n  }\n\n  canProxy (sessionId) {\n    const dstSession = this.sessions[sessionId];\n    return dstSession && dstSession.canProxy(sessionId);\n  }\n}\n\n// help decide which commands should be proxied to sub-drivers and which\n// should be handled by this, our umbrella driver\nfunction isAppiumDriverCommand (cmd) {\n  return !isSessionCommand(cmd) || cmd === 'deleteSession';\n}\n\nexport { AppiumDriver };\n"],"file":"lib/appium.js","sourceRoot":"../.."}
+    return !(0, base_driver_1.isSessionCommand)(cmd) || cmd === base_driver_1.DELETE_SESSION_COMMAND;
+}
+/**
+ * Thrown when Appium tried to proxy a command using a driver's `proxyCommand` method but the
+ * method did not exist
+ */
+class NoDriverProxyCommandError extends Error {
+    constructor() {
+        super(`The default behavior for this command was to proxy, but the driver ` +
+            `did not have the 'proxyCommand' method defined. To fully support ` +
+            `plugins, drivers should have 'proxyCommand' set to a jwpProxy object's ` +
+            `'command()' method, in addition to the normal 'proxyReqRes'`);
+        /**
+         * @type {Readonly<string>}
+         */
+        this.code = 'APPIUMERR_NO_DRIVER_PROXYCOMMAND';
+    }
+}
+exports.NoDriverProxyCommandError = NoDriverProxyCommandError;
+/**
+ * @typedef {import('@appium/types').DriverData} DriverData
+ * @typedef {import('@appium/types').ServerArgs} DriverOpts
+ * @typedef {import('@appium/types').Constraints} Constraints
+ * @typedef {import('@appium/types').AppiumServer} AppiumServer
+ * @typedef {import('@appium/types').ExtensionType} ExtensionType
+ * @typedef {import('./extension/driver-config').DriverConfig} DriverConfig
+ * @typedef {import('@appium/types').PluginType} PluginType
+ * @typedef {import('@appium/types').DriverType} DriverType
+ * @typedef {import('@appium/types').StringRecord} StringRecord
+ * @typedef {import('@appium/types').ExternalDriver} ExternalDriver
+ * @typedef {import('@appium/types').PluginClass} PluginClass
+ * @typedef {import('@appium/types').Plugin} Plugin
+ * @typedef {import('@appium/types').DriverClass<import('@appium/types').Driver>} DriverClass
+ */
+/**
+ * @typedef {import('@appium/types').ISessionHandler<AppiumDriverConstraints,
+ * SessionHandlerCreateResult, SessionHandlerDeleteResult>} AppiumSessionHandler
+ */
+/**
+ * @typedef {SessionHandlerResult<[innerSessionId: string, caps:
+ * import('@appium/types').DriverCaps<Constraints>, protocol: string|undefined]>} SessionHandlerCreateResult
+ */
+/**
+ * @template {Constraints} C
+ * @typedef {import('@appium/types').Core<C>} Core
+ */
+/**
+ * @typedef {SessionHandlerResult<void>} SessionHandlerDeleteResult
+ */
+/**
+ * Used by {@linkcode AppiumDriver.createSession} and {@linkcode AppiumDriver.deleteSession} to describe
+ * result.
+ * @template V
+ * @typedef SessionHandlerResult
+ * @property {V} [value]
+ * @property {Error} [error]
+ * @property {string} [protocol]
+ */
+/**
+ * @typedef {typeof desiredCapabilityConstraints} AppiumDriverConstraints
+ * @typedef {import('@appium/types').W3CDriverCaps<AppiumDriverConstraints>} W3CAppiumDriverCaps
+ */
+//# sourceMappingURL=appium.js.map