appium-chromedriver 5.2.17 → 5.3.0

package/build/lib/chromedriver.js

@@ -1,25 +1,23 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.Chromedriver = void 0;
-require("source-map-support/register");
-var _events = _interopRequireDefault(require("events"));
-var _baseDriver = require("@appium/base-driver");
-var _child_process = _interopRequireDefault(require("child_process"));
-var _support = require("@appium/support");
-var _asyncbox = require("asyncbox");
-var _teen_process = require("teen_process");
-var _bluebird = _interopRequireDefault(require("bluebird"));
-var _utils = require("./utils");
-var _semver = _interopRequireDefault(require("semver"));
-var _lodash = _interopRequireDefault(require("lodash"));
-var _path = _interopRequireDefault(require("path"));
-var _compareVersions = require("compare-versions");
-var _storageClient = _interopRequireDefault(require("./storage-client"));
-var _protocolHelpers = require("./protocol-helpers");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chromedriver = void 0;
+const events_1 = __importDefault(require("events"));
+const base_driver_1 = require("@appium/base-driver");
+const child_process_1 = __importDefault(require("child_process"));
+const support_1 = require("@appium/support");
+const asyncbox_1 = require("asyncbox");
+const teen_process_1 = require("teen_process");
+const bluebird_1 = __importDefault(require("bluebird"));
+const utils_1 = require("./utils");
+const semver_1 = __importDefault(require("semver"));
+const lodash_1 = __importDefault(require("lodash"));
+const path_1 = __importDefault(require("path"));
+const compare_versions_1 = require("compare-versions");
+const storage_client_1 = __importDefault(require("./storage-client"));
+const protocol_helpers_1 = require("./protocol-helpers");
 const NEW_CD_VERSION_FORMAT_MAJOR_VERSION = 73;
 const DEFAULT_HOST = '127.0.0.1';
 const MIN_CD_VERSION_WITH_W3C_SUPPORT = 75;
@@ -29,550 +27,676 @@ const WEBVIEW_SHELL_BUNDLE_ID = 'org.chromium.webview_shell';
 const WEBVIEW_BUNDLE_IDS = ['com.google.android.webview', 'com.android.webview'];
 const VERSION_PATTERN = /([\d.]+)/;
 const CD_VERSION_TIMEOUT = 5000;
-class Chromedriver extends _events.default.EventEmitter {
-  constructor(args = {}) {
-    super();
-    const {
-      host = DEFAULT_HOST,
-      port = DEFAULT_PORT,
-      useSystemExecutable = false,
-      executable,
-      executableDir = (0, _utils.getChromedriverDir)(),
-      bundleId,
-      mappingPath,
-      cmdArgs,
-      adb,
-      verbose,
-      logPath,
-      disableBuildCheck,
-      details,
-      isAutodownloadEnabled = false
-    } = args;
-    this._log = _support.logger.getLogger((0, _utils.generateLogPrefix)(this));
-    this.proxyHost = host;
-    this.proxyPort = port;
-    this.adb = adb;
-    this.cmdArgs = cmdArgs;
-    this.proc = null;
-    this.useSystemExecutable = useSystemExecutable;
-    this.chromedriver = executable;
-    this.executableDir = executableDir;
-    this.mappingPath = mappingPath;
-    this.bundleId = bundleId;
-    this.executableVerified = false;
-    this.state = Chromedriver.STATE_STOPPED;
-    this.jwproxy = new _baseDriver.JWProxy({
-      server: this.proxyHost,
-      port: this.proxyPort,
-      log: this._log
-    });
-    this.verbose = verbose;
-    this.logPath = logPath;
-    this.disableBuildCheck = !!disableBuildCheck;
-    this.storageClient = isAutodownloadEnabled ? new _storageClient.default({
-      chromedriverDir: this.executableDir
-    }) : null;
-    this.details = details;
-    this.capabilities = {};
-    this.desiredProtocol = _baseDriver.PROTOCOLS.MJSONWP;
-  }
-  get log() {
-    return this._log;
-  }
-  async getDriversMapping() {
-    let mapping = _lodash.default.cloneDeep(_utils.CHROMEDRIVER_CHROME_MAPPING);
-    if (this.mappingPath) {
-      this.log.debug(`Attempting to use Chromedriver->Chrome mapping from '${this.mappingPath}'`);
-      if (!(await _support.fs.exists(this.mappingPath))) {
-        this.log.warn(`No file found at '${this.mappingPath}'`);
-        this.log.info('Defaulting to the static Chromedriver->Chrome mapping');
-      } else {
-        try {
-          mapping = JSON.parse(await _support.fs.readFile(this.mappingPath, 'utf8'));
-        } catch (err) {
-          this.log.warn(`Error parsing mapping from '${this.mappingPath}': ${err.message}`);
-          this.log.info('Defaulting to the static Chromedriver->Chrome mapping');
-        }
-      }
-    } else {
-      this.log.debug('Using the static Chromedriver->Chrome mapping');
-    }
-    for (const [cdVersion, chromeVersion] of _lodash.default.toPairs(mapping)) {
-      const coercedVersion = _semver.default.coerce(chromeVersion);
-      if (coercedVersion) {
-        mapping[cdVersion] = coercedVersion.version;
-      } else {
-        this.log.info(`'${chromeVersion}' is not a valid version number. Skipping it`);
-      }
-    }
-    return mapping;
-  }
-  async getChromedrivers(mapping) {
-    const executables = await _support.fs.glob('*', {
-      cwd: this.executableDir,
-      strict: false,
-      nodir: true,
-      absolute: true
-    });
-    this.log.debug(`Found ${_support.util.pluralize('executable', executables.length, true)} ` + `in '${this.executableDir}'`);
-    const cds = (await (0, _asyncbox.asyncmap)(executables, async executable => {
-      const logError = ({
-        message,
-        stdout = null,
-        stderr = null
-      }) => {
-        let errMsg = `Cannot retrieve version number from '${_path.default.basename(executable)}' Chromedriver binary. ` + `Make sure it returns a valid version string in response to '--version' command line argument. ${message}`;
-        if (stdout) {
-          errMsg += `\nStdout: ${stdout}`;
-        }
-        if (stderr) {
-          errMsg += `\nStderr: ${stderr}`;
-        }
-        this.log.warn(errMsg);
-        return null;
-      };
-      let stdout;
-      let stderr;
-      try {
-        ({
-          stdout,
-          stderr
-        } = await (0, _teen_process.exec)(executable, ['--version'], {
-          timeout: CD_VERSION_TIMEOUT
-        }));
-      } catch (err) {
-        if (!(err.message || '').includes('timed out') && !(err.stdout || '').includes('Starting ChromeDriver')) {
-          return logError(err);
-        }
-        stdout = err.stdout;
-      }
-      const match = /ChromeDriver\s+\(?v?([\d.]+)\)?/i.exec(stdout);
-      if (!match) {
-        return logError({
-          message: 'Cannot parse the version string',
-          stdout,
-          stderr
+class Chromedriver extends events_1.default.EventEmitter {
+    /**
+     *
+     * @param {import('./types').ChromedriverOpts} args
+     */
+    constructor(args = {}) {
+        super();
+        const { host = DEFAULT_HOST, port = DEFAULT_PORT, useSystemExecutable = false, executable, executableDir = (0, utils_1.getChromedriverDir)(), bundleId, mappingPath, cmdArgs, adb, verbose, logPath, disableBuildCheck, details, isAutodownloadEnabled = false, } = args;
+        this._log = support_1.logger.getLogger((0, utils_1.generateLogPrefix)(this));
+        this.proxyHost = host;
+        this.proxyPort = port;
+        this.adb = adb;
+        this.cmdArgs = cmdArgs;
+        this.proc = null;
+        this.useSystemExecutable = useSystemExecutable;
+        this.chromedriver = executable;
+        this.executableDir = executableDir;
+        this.mappingPath = mappingPath;
+        this.bundleId = bundleId;
+        this.executableVerified = false;
+        this.state = Chromedriver.STATE_STOPPED;
+        this.jwproxy = new base_driver_1.JWProxy({
+            server: this.proxyHost,
+            port: this.proxyPort,
+            log: this._log,
         });
-      }
-      let version = match[1];
-      let minChromeVersion = mapping[version];
-      const coercedVersion = _semver.default.coerce(version);
-      if (coercedVersion) {
-        if (coercedVersion.major < NEW_CD_VERSION_FORMAT_MAJOR_VERSION) {
-          version = `${coercedVersion.major}.${coercedVersion.minor}`;
-          minChromeVersion = mapping[version];
-        }
-        if (!minChromeVersion && coercedVersion.major >= NEW_CD_VERSION_FORMAT_MAJOR_VERSION) {
-          minChromeVersion = `${coercedVersion.major}`;
-        }
-      }
-      return {
-        executable,
-        version,
-        minChromeVersion
-      };
-    })).filter(cd => !!cd).sort((a, b) => (0, _compareVersions.compareVersions)(b.version, a.version));
-    if (_lodash.default.isEmpty(cds)) {
-      this.log.info(`No Chromedrivers were found in '${this.executableDir}'`);
-      return cds;
-    }
-    this.log.debug(`The following Chromedriver executables were found:`);
-    for (const cd of cds) {
-      this.log.debug(`    '${cd.executable}' (version '${cd.version}', minimum Chrome version '${cd.minChromeVersion ? cd.minChromeVersion : 'Unknown'}')`);
-    }
-    return cds;
-  }
-  async getChromeVersion() {
-    var _this$details, _this$details3, _this$details3$info;
-    if ((_this$details = this.details) !== null && _this$details !== void 0 && _this$details.info) {
-      var _this$details2, _this$details2$info;
-      this.log.debug(`Browser version in the supplied details: ${(_this$details2 = this.details) === null || _this$details2 === void 0 ? void 0 : (_this$details2$info = _this$details2.info) === null || _this$details2$info === void 0 ? void 0 : _this$details2$info.Browser}`);
-    }
-    const versionMatch = VERSION_PATTERN.exec((_this$details3 = this.details) === null || _this$details3 === void 0 ? void 0 : (_this$details3$info = _this$details3.info) === null || _this$details3$info === void 0 ? void 0 : _this$details3$info.Browser);
-    if (versionMatch) {
-      const coercedVersion = _semver.default.coerce(versionMatch[1]);
-      if (coercedVersion) {
-        return coercedVersion;
-      }
-    }
-    let chromeVersion;
-    if (this.bundleId === WEBVIEW_SHELL_BUNDLE_ID) {
-      for (const bundleId of WEBVIEW_BUNDLE_IDS) {
-        chromeVersion = await (0, _utils.getChromeVersion)(this.adb, bundleId);
-        if (chromeVersion) {
-          this.bundleId = bundleId;
-          return _semver.default.coerce(chromeVersion);
-        }
-      }
-      return null;
-    }
-    if (this.adb) {
-      const apiLevel = await this.adb.getApiLevel();
-      if (apiLevel >= 24 && apiLevel <= 28 && [WEBVIEW_SHELL_BUNDLE_ID, ...WEBVIEW_BUNDLE_IDS].includes(this.bundleId)) {
-        this.bundleId = CHROME_BUNDLE_ID;
-      }
-    }
-    if (!this.bundleId) {
-      this.bundleId = CHROME_BUNDLE_ID;
-      for (const bundleId of WEBVIEW_BUNDLE_IDS) {
-        chromeVersion = await (0, _utils.getChromeVersion)(this.adb, bundleId);
-        if (chromeVersion) {
-          this.bundleId = bundleId;
-          break;
-        }
-      }
-    }
-    if (!chromeVersion) {
-      chromeVersion = await (0, _utils.getChromeVersion)(this.adb, this.bundleId);
-    }
-    return chromeVersion ? _semver.default.coerce(chromeVersion) : null;
-  }
-  async updateDriversMapping(newMapping) {
-    let shouldUpdateStaticMapping = true;
-    if (await _support.fs.exists(this.mappingPath)) {
-      try {
-        await _support.fs.writeFile(this.mappingPath, JSON.stringify(newMapping, null, 2), 'utf8');
-        shouldUpdateStaticMapping = false;
-      } catch (e) {
-        this.log.warn(`Cannot store the updated chromedrivers mapping into '${this.mappingPath}'. ` + `This may reduce the performance of further executions. Original error: ${e.message}`);
-      }
-    }
-    if (shouldUpdateStaticMapping) {
-      Object.assign(_utils.CHROMEDRIVER_CHROME_MAPPING, newMapping);
-    }
-  }
-  async getCompatibleChromedriver() {
-    if (!this.adb) {
-      return await (0, _utils.getChromedriverBinaryPath)();
-    }
-    const mapping = await this.getDriversMapping();
-    if (!_lodash.default.isEmpty(mapping)) {
-      this.log.debug(`The most recent known Chrome version: ${_lodash.default.values(mapping)[0]}`);
-    }
-    let didStorageSync = false;
-    const syncChromedrivers = async chromeVersion => {
-      didStorageSync = true;
-      const retrievedMapping = await this.storageClient.retrieveMapping();
-      this.log.debug('Got chromedrivers mapping from the storage: ' + JSON.stringify(retrievedMapping, null, 2));
-      const driverKeys = await this.storageClient.syncDrivers({
-        minBrowserVersion: chromeVersion.major
-      });
-      if (_lodash.default.isEmpty(driverKeys)) {
-        return false;
-      }
-      const synchronizedDriversMapping = driverKeys.reduce((acc, x) => {
-        const {
-          version,
-          minBrowserVersion
-        } = retrievedMapping[x];
-        acc[version] = minBrowserVersion;
-        return acc;
-      }, {});
-      Object.assign(mapping, synchronizedDriversMapping);
-      await this.updateDriversMapping(mapping);
-      return true;
-    };
-    do {
-      const cds = await this.getChromedrivers(mapping);
-      const missingVersions = {};
-      for (const {
-        version,
-        minChromeVersion
-      } of cds) {
-        if (!minChromeVersion || mapping[version]) {
-          continue;
-        }
-        const coercedVer = _semver.default.coerce(version);
-        if (!coercedVer || coercedVer.major < NEW_CD_VERSION_FORMAT_MAJOR_VERSION) {
-          continue;
-        }
-        missingVersions[version] = minChromeVersion;
-      }
-      if (!_lodash.default.isEmpty(missingVersions)) {
-        this.log.info(`Found ${_support.util.pluralize('Chromedriver', _lodash.default.size(missingVersions), true)}, ` + `which ${_lodash.default.size(missingVersions) === 1 ? 'is' : 'are'} missing in the list of known versions: ` + JSON.stringify(missingVersions));
-        await this.updateDriversMapping(Object.assign(mapping, missingVersions));
-      }
-      if (this.disableBuildCheck) {
-        if (_lodash.default.isEmpty(cds)) {
-          this.log.errorAndThrow(`There must be at least one Chromedriver executable available for use if ` + `'chromedriverDisableBuildCheck' capability is set to 'true'`);
-        }
-        const {
-          version,
-          executable
-        } = cds[0];
-        this.log.warn(`Chrome build check disabled. Using most recent Chromedriver version (${version}, at '${executable}')`);
-        this.log.warn(`If this is wrong, set 'chromedriverDisableBuildCheck' capability to 'false'`);
-        return executable;
-      }
-      const chromeVersion = await this.getChromeVersion();
-      if (!chromeVersion) {
-        if (_lodash.default.isEmpty(cds)) {
-          this.log.errorAndThrow(`There must be at least one Chromedriver executable available for use if ` + `the current Chrome version cannot be determined`);
-        }
-        const {
-          version,
-          executable
-        } = cds[0];
-        this.log.warn(`Unable to discover Chrome version. Using Chromedriver ${version} at '${executable}'`);
-        return executable;
-      }
-      this.log.debug(`Found Chrome bundle '${this.bundleId}' version '${chromeVersion}'`);
-      const matchingDrivers = cds.filter(({
-        minChromeVersion
-      }) => {
-        const minChromeVersionS = minChromeVersion && _semver.default.coerce(minChromeVersion);
-        if (!minChromeVersionS) {
-          return false;
-        }
-        return chromeVersion.major > NEW_CD_VERSION_FORMAT_MAJOR_VERSION ? minChromeVersionS.major === chromeVersion.major : _semver.default.gte(chromeVersion, minChromeVersionS);
-      });
-      if (_lodash.default.isEmpty(matchingDrivers)) {
-        if (this.storageClient && !didStorageSync) {
-          try {
-            if (await syncChromedrivers(chromeVersion)) {
-              continue;
+        this.verbose = verbose;
+        this.logPath = logPath;
+        this.disableBuildCheck = !!disableBuildCheck;
+        this.storageClient = isAutodownloadEnabled
+            ? new storage_client_1.default({ chromedriverDir: this.executableDir })
+            : null;
+        this.details = details;
+        /** @type {any} */
+        this.capabilities = {};
+        this.desiredProtocol = base_driver_1.PROTOCOLS.MJSONWP;
+    }
+    get log() {
+        return this._log;
+    }
+    async getDriversMapping() {
+        let mapping = lodash_1.default.cloneDeep(utils_1.CHROMEDRIVER_CHROME_MAPPING);
+        if (this.mappingPath) {
+            this.log.debug(`Attempting to use Chromedriver->Chrome mapping from '${this.mappingPath}'`);
+            if (!(await support_1.fs.exists(this.mappingPath))) {
+                this.log.warn(`No file found at '${this.mappingPath}'`);
+                this.log.info('Defaulting to the static Chromedriver->Chrome mapping');
             }
-          } catch (e) {
-            this.log.warn(`Cannot synchronize local chromedrivers with the remote storage at ${_utils.CD_CDN}: ` + e.message);
-            this.log.debug(e.stack);
-          }
-        }
-        const autodownloadSuggestion = 'You could also try to enable automated chromedrivers download as ' + 'a possible workaround.';
-        throw new Error(`No Chromedriver found that can automate Chrome '${chromeVersion}'.` + (this.storageClient ? '' : ` ${autodownloadSuggestion}`));
-      }
-      const binPath = matchingDrivers[0].executable;
-      this.log.debug(`Found ${_support.util.pluralize('executable', matchingDrivers.length, true)} ` + `capable of automating Chrome '${chromeVersion}'.\nChoosing the most recent, '${binPath}'.`);
-      this.log.debug('If a specific version is required, specify it with the `chromedriverExecutable`' + 'desired capability.');
-      return binPath;
-    } while (true);
-  }
-  async initChromedriverPath() {
-    if (this.executableVerified) return;
-    if (!this.chromedriver) {
-      this.chromedriver = this.useSystemExecutable ? await (0, _utils.getChromedriverBinaryPath)() : await this.getCompatibleChromedriver();
-    }
-    if (!(await _support.fs.exists(this.chromedriver))) {
-      throw new Error(`Trying to use a chromedriver binary at the path ` + `${this.chromedriver}, but it doesn't exist!`);
-    }
-    this.executableVerified = true;
-    this.log.info(`Set chromedriver binary as: ${this.chromedriver}`);
-  }
-  syncProtocol(cdVersion = null) {
-    const coercedVersion = _semver.default.coerce(cdVersion);
-    if (!coercedVersion || coercedVersion.major < MIN_CD_VERSION_WITH_W3C_SUPPORT) {
-      this.log.debug(`Chromedriver v. ${cdVersion} does not fully support ${_baseDriver.PROTOCOLS.W3C} protocol. ` + `Defaulting to ${_baseDriver.PROTOCOLS.MJSONWP}`);
-      return;
-    }
-    const chromeOptions = (0, _protocolHelpers.getCapValue)(this.capabilities, 'chromeOptions', {});
-    if (chromeOptions.w3c === false) {
-      this.log.info(`Chromedriver v. ${cdVersion} supports ${_baseDriver.PROTOCOLS.W3C} protocol, ` + `but ${_baseDriver.PROTOCOLS.MJSONWP} one has been explicitly requested`);
-      return;
-    }
-    this.desiredProtocol = _baseDriver.PROTOCOLS.W3C;
-    this.capabilities = (0, _protocolHelpers.toW3cCapNames)(this.capabilities);
-  }
-  async start(caps, emitStartingState = true) {
-    this.capabilities = _lodash.default.cloneDeep(caps);
-    this.capabilities.loggingPrefs = _lodash.default.cloneDeep((0, _protocolHelpers.getCapValue)(caps, 'loggingPrefs', {}));
-    if (_lodash.default.isEmpty(this.capabilities.loggingPrefs.browser)) {
-      this.capabilities.loggingPrefs.browser = 'ALL';
-    }
-    if (emitStartingState) {
-      this.changeState(Chromedriver.STATE_STARTING);
-    }
-    const args = [`--port=${this.proxyPort}`];
-    if (this.adb && this.adb.adbPort) {
-      args.push(`--adb-port=${this.adb.adbPort}`);
-    }
-    if (_lodash.default.isArray(this.cmdArgs)) {
-      args.push(...this.cmdArgs);
-    }
-    if (this.logPath) {
-      args.push(`--log-path=${this.logPath}`);
-    }
-    if (this.disableBuildCheck) {
-      args.push('--disable-build-check');
-    }
-    args.push('--verbose');
-    const startDetector = stdout => stdout.startsWith('Starting ');
-    let processIsAlive = false;
-    let webviewVersion;
-    try {
-      await this.initChromedriverPath();
-      await this.killAll();
-      this.proc = new _teen_process.SubProcess(this.chromedriver, args);
-      processIsAlive = true;
-      this.proc.on('output', (stdout, stderr) => {
-        const out = stdout + stderr;
-        let match = /"Browser": "(.*)"/.exec(out);
-        if (match) {
-          webviewVersion = match[1];
-          this.log.debug(`Webview version: '${webviewVersion}'`);
-        }
-        match = /Starting ChromeDriver ([.\d]+)/.exec(out);
-        if (match) {
-          this.log.debug(`Chromedriver version: '${match[1]}'`);
-          this.syncProtocol(match[1]);
-        }
-        if (this.verbose) {
-          for (let line of (stdout || '').trim().split('\n')) {
-            if (!line.trim().length) continue;
-            this.log.debug(`[STDOUT] ${line}`);
-          }
-          for (let line of (stderr || '').trim().split('\n')) {
-            if (!line.trim().length) continue;
-            this.log.error(`[STDERR] ${line}`);
-          }
-        }
-      });
-      this.proc.on('exit', (code, signal) => {
-        processIsAlive = false;
-        if (this.state !== Chromedriver.STATE_STOPPED && this.state !== Chromedriver.STATE_STOPPING && this.state !== Chromedriver.STATE_RESTARTING) {
-          const msg = `Chromedriver exited unexpectedly with code ${code}, signal ${signal}`;
-          this.log.error(msg);
-          this.changeState(Chromedriver.STATE_STOPPED);
-        }
-      });
-      this.log.info(`Spawning chromedriver with: ${this.chromedriver} ${args.join(' ')}`);
-      await this.proc.start(startDetector);
-      await this.waitForOnline();
-      await this.startSession();
-    } catch (e) {
-      this.log.debug(e);
-      this.emit(Chromedriver.EVENT_ERROR, e);
-      if (processIsAlive) {
-        await this.proc.stop();
-      }
-      let message = '';
-      if (e.message.includes('Chrome version must be')) {
-        var _exec;
-        message += 'Unable to automate Chrome version because it is not supported by this version of Chromedriver.\n';
-        if (webviewVersion) {
-          message += `Chrome version on the device: ${webviewVersion}\n`;
-        }
-        const versionsSupportedByDriver = ((_exec = /Chrome version must be (.+)/.exec(e.message)) === null || _exec === void 0 ? void 0 : _exec[1]) || '';
-        if (versionsSupportedByDriver) {
-          message += `Chromedriver supports Chrome version(s): ${versionsSupportedByDriver}\n`;
-        }
-        message += 'Check the driver tutorial for troubleshooting.\n';
-      }
-      message += e.message;
-      this.log.errorAndThrow(message);
-    }
-  }
-  sessionId() {
-    return this.state === Chromedriver.STATE_ONLINE ? this.jwproxy.sessionId : null;
-  }
-  async restart() {
-    this.log.info('Restarting chromedriver');
-    if (this.state !== Chromedriver.STATE_ONLINE) {
-      throw new Error("Can't restart when we're not online");
+            else {
+                try {
+                    mapping = JSON.parse(await support_1.fs.readFile(this.mappingPath, 'utf8'));
+                }
+                catch (e) {
+                    const err = /** @type {Error} */ (e);
+                    this.log.warn(`Error parsing mapping from '${this.mappingPath}': ${err.message}`);
+                    this.log.info('Defaulting to the static Chromedriver->Chrome mapping');
+                }
+            }
+        }
+        else {
+            this.log.debug('Using the static Chromedriver->Chrome mapping');
+        }
+        // make sure that the values for minimum chrome version are semver compliant
+        for (const [cdVersion, chromeVersion] of lodash_1.default.toPairs(mapping)) {
+            const coercedVersion = semver_1.default.coerce(chromeVersion);
+            if (coercedVersion) {
+                mapping[cdVersion] = coercedVersion.version;
+            }
+            else {
+                this.log.info(`'${chromeVersion}' is not a valid version number. Skipping it`);
+            }
+        }
+        return mapping;
+    }
+    /**
+     * @param {ChromedriverVersionMapping} mapping
+     */
+    async getChromedrivers(mapping) {
+        // go through the versions available
+        const executables = await support_1.fs.glob('*', {
+            cwd: this.executableDir,
+            strict: false,
+            nodir: true,
+            absolute: true,
+        });
+        this.log.debug(`Found ${support_1.util.pluralize('executable', executables.length, true)} ` +
+            `in '${this.executableDir}'`);
+        const cds = (await (0, asyncbox_1.asyncmap)(executables, async (executable) => {
+            /**
+             * @param {{message: string, stdout?: string, stderr?: string}} opts
+             */
+            const logError = ({ message, stdout, stderr }) => {
+                let errMsg = `Cannot retrieve version number from '${path_1.default.basename(executable)}' Chromedriver binary. ` +
+                    `Make sure it returns a valid version string in response to '--version' command line argument. ${message}`;
+                if (stdout) {
+                    errMsg += `\nStdout: ${stdout}`;
+                }
+                if (stderr) {
+                    errMsg += `\nStderr: ${stderr}`;
+                }
+                this.log.warn(errMsg);
+                return null;
+            };
+            let stdout;
+            let stderr;
+            try {
+                ({ stdout, stderr } = await (0, teen_process_1.exec)(executable, ['--version'], {
+                    timeout: CD_VERSION_TIMEOUT,
+                }));
+            }
+            catch (e) {
+                const err = /** @type {import('teen_process').ExecError} */ (e);
+                if (!(err.message || '').includes('timed out') &&
+                    !(err.stdout || '').includes('Starting ChromeDriver')) {
+                    return logError(err);
+                }
+                // if this has timed out, it has actually started Chromedriver,
+                // in which case there will also be the version string in the output
+                stdout = err.stdout;
+            }
+            const match = /ChromeDriver\s+\(?v?([\d.]+)\)?/i.exec(stdout); // https://regex101.com/r/zpj5wA/1
+            if (!match) {
+                return logError({ message: 'Cannot parse the version string', stdout, stderr });
+            }
+            let version = match[1];
+            let minChromeVersion = mapping[version];
+            const coercedVersion = semver_1.default.coerce(version);
+            if (coercedVersion) {
+                // before 2019-03-06 versions were of the form major.minor
+                if (coercedVersion.major < NEW_CD_VERSION_FORMAT_MAJOR_VERSION) {
+                    version = /** @type {keyof typeof mapping} */ (`${coercedVersion.major}.${coercedVersion.minor}`);
+                    minChromeVersion = mapping[version];
+                }
+                if (!minChromeVersion && coercedVersion.major >= NEW_CD_VERSION_FORMAT_MAJOR_VERSION) {
+                    // Assume the major Chrome version is the same as the corresponding driver major version
+                    minChromeVersion = `${coercedVersion.major}`;
+                }
+            }
+            return {
+                executable,
+                version,
+                minChromeVersion,
+            };
+        }))
+            .filter((cd) => !!cd)
+            .sort((a, b) => (0, compare_versions_1.compareVersions)(b.version, a.version));
+        if (lodash_1.default.isEmpty(cds)) {
+            this.log.info(`No Chromedrivers were found in '${this.executableDir}'`);
+            return cds;
+        }
+        this.log.debug(`The following Chromedriver executables were found:`);
+        for (const cd of cds) {
+            this.log.debug(`    '${cd.executable}' (version '${cd.version}', minimum Chrome version '${cd.minChromeVersion ? cd.minChromeVersion : 'Unknown'}')`);
+        }
+        return cds;
+    }
+    async getChromeVersion() {
+        // Try to retrieve the version from `details` property if it is set
+        // The `info` item must contain the output of /json/version CDP command
+        // where `Browser` field looks like `Chrome/72.0.3601.0``
+        if (this.details?.info) {
+            this.log.debug(`Browser version in the supplied details: ${this.details?.info?.Browser}`);
+        }
+        const versionMatch = VERSION_PATTERN.exec(this.details?.info?.Browser ?? '');
+        if (versionMatch) {
+            const coercedVersion = semver_1.default.coerce(versionMatch[1]);
+            if (coercedVersion) {
+                return coercedVersion;
+            }
+        }
+        let chromeVersion;
+        // in case of WebView Browser Tester, simply try to find the underlying webview
+        if (this.bundleId === WEBVIEW_SHELL_BUNDLE_ID) {
+            if (this.adb) {
+                for (const bundleId of WEBVIEW_BUNDLE_IDS) {
+                    chromeVersion = await (0, utils_1.getChromeVersion)(this.adb, bundleId);
+                    if (chromeVersion) {
+                        this.bundleId = bundleId;
+                        return semver_1.default.coerce(chromeVersion);
+                    }
+                }
+            }
+            return null;
+        }
+        // on Android 7-9 webviews are backed by the main Chrome, not the system webview
+        if (this.adb) {
+            const apiLevel = await this.adb.getApiLevel();
+            if (apiLevel >= 24 &&
+                apiLevel <= 28 &&
+                [WEBVIEW_SHELL_BUNDLE_ID, ...WEBVIEW_BUNDLE_IDS].includes(this.bundleId ?? '')) {
+                this.bundleId = CHROME_BUNDLE_ID;
+            }
+        }
+        // try out webviews when no bundle id is sent in
+        if (!this.bundleId) {
+            // default to the generic Chrome bundle
+            this.bundleId = CHROME_BUNDLE_ID;
+            // we have a webview of some sort, so try to find the bundle version
+            for (const bundleId of WEBVIEW_BUNDLE_IDS) {
+                if (this.adb) {
+                    chromeVersion = await (0, utils_1.getChromeVersion)(this.adb, bundleId);
+                    if (chromeVersion) {
+                        this.bundleId = bundleId;
+                        break;
+                    }
+                }
+            }
+        }
+        // if we do not have a chrome version, it must not be a webview
+        if (!chromeVersion && this.adb) {
+            chromeVersion = await (0, utils_1.getChromeVersion)(this.adb, this.bundleId);
+        }
+        // make sure it is semver, so later checks won't fail
+        return chromeVersion ? semver_1.default.coerce(chromeVersion) : null;
+    }
+    /**
+     *
+     * @param {ChromedriverVersionMapping} newMapping
+     * @returns {Promise<void>}
+     */
+    async updateDriversMapping(newMapping) {
+        let shouldUpdateStaticMapping = true;
+        if (!this.mappingPath) {
+            this.log.warn('No mapping path provided');
+            return;
+        }
+        if (await support_1.fs.exists(this.mappingPath)) {
+            try {
+                await support_1.fs.writeFile(this.mappingPath, JSON.stringify(newMapping, null, 2), 'utf8');
+                shouldUpdateStaticMapping = false;
+            }
+            catch (e) {
+                const err = /** @type {Error} */ (e);
+                this.log.warn(`Cannot store the updated chromedrivers mapping into '${this.mappingPath}'. ` +
+                    `This may reduce the performance of further executions. Original error: ${err.message}`);
+            }
+        }
+        if (shouldUpdateStaticMapping) {
+            Object.assign(utils_1.CHROMEDRIVER_CHROME_MAPPING, newMapping);
+        }
     }
-    this.changeState(Chromedriver.STATE_RESTARTING);
-    await this.stop(false);
-    await this.start(this.capabilities, false);
-  }
-  async waitForOnline() {
-    let chromedriverStopped = false;
-    await (0, _asyncbox.retryInterval)(20, 200, async () => {
-      if (this.state === Chromedriver.STATE_STOPPED) {
-        chromedriverStopped = true;
-        return;
-      }
-      await this.getStatus();
-    });
-    if (chromedriverStopped) {
-      throw new Error('ChromeDriver crashed during startup.');
+    /**
+     * @returns {Promise<string>}
+     */
+    async getCompatibleChromedriver() {
+        if (!this.adb) {
+            return await (0, utils_1.getChromedriverBinaryPath)();
+        }
+        const mapping = await this.getDriversMapping();
+        if (!lodash_1.default.isEmpty(mapping)) {
+            this.log.debug(`The most recent known Chrome version: ${lodash_1.default.values(mapping)[0]}`);
+        }
+        let didStorageSync = false;
+        /**
+         *
+         * @param {import('semver').SemVer} chromeVersion
+         */
+        const syncChromedrivers = async (chromeVersion) => {
+            didStorageSync = true;
+            if (!this.storageClient) {
+                return false;
+            }
+            const retrievedMapping = await this.storageClient.retrieveMapping();
+            this.log.debug('Got chromedrivers mapping from the storage: ' + JSON.stringify(retrievedMapping, null, 2));
+            const driverKeys = await this.storageClient.syncDrivers({
+                minBrowserVersion: chromeVersion.major,
+            });
+            if (lodash_1.default.isEmpty(driverKeys)) {
+                return false;
+            }
+            const synchronizedDriversMapping = driverKeys.reduce((acc, x) => {
+                const { version, minBrowserVersion } = retrievedMapping[x];
+                acc[version] = minBrowserVersion;
+                return acc;
+            }, /** @type {ChromedriverVersionMapping} */ ({}));
+            Object.assign(mapping, synchronizedDriversMapping);
+            await this.updateDriversMapping(mapping);
+            return true;
+        };
+        do {
+            const cds = await this.getChromedrivers(mapping);
+            /** @type {ChromedriverVersionMapping} */
+            const missingVersions = {};
+            for (const { version, minChromeVersion } of cds) {
+                if (!minChromeVersion || mapping[version]) {
+                    continue;
+                }
+                const coercedVer = semver_1.default.coerce(version);
+                if (!coercedVer || coercedVer.major < NEW_CD_VERSION_FORMAT_MAJOR_VERSION) {
+                    continue;
+                }
+                missingVersions[version] = minChromeVersion;
+            }
+            if (!lodash_1.default.isEmpty(missingVersions)) {
+                this.log.info(`Found ${support_1.util.pluralize('Chromedriver', lodash_1.default.size(missingVersions), true)}, ` +
+                    `which ${lodash_1.default.size(missingVersions) === 1 ? 'is' : 'are'} missing in the list of known versions: ` +
+                    JSON.stringify(missingVersions));
+                await this.updateDriversMapping(Object.assign(mapping, missingVersions));
+            }
+            if (this.disableBuildCheck) {
+                if (lodash_1.default.isEmpty(cds)) {
+                    this.log.errorAndThrow(`There must be at least one Chromedriver executable available for use if ` +
+                        `'chromedriverDisableBuildCheck' capability is set to 'true'`);
+                }
+                const { version, executable } = cds[0];
+                this.log.warn(`Chrome build check disabled. Using most recent Chromedriver version (${version}, at '${executable}')`);
+                this.log.warn(`If this is wrong, set 'chromedriverDisableBuildCheck' capability to 'false'`);
+                return executable;
+            }
+            const chromeVersion = await this.getChromeVersion();
+            if (!chromeVersion) {
+                // unable to get the chrome version
+                if (lodash_1.default.isEmpty(cds)) {
+                    this.log.errorAndThrow(`There must be at least one Chromedriver executable available for use if ` +
+                        `the current Chrome version cannot be determined`);
+                }
+                const { version, executable } = cds[0];
+                this.log.warn(`Unable to discover Chrome version. Using Chromedriver ${version} at '${executable}'`);
+                return executable;
+            }
+            this.log.debug(`Found Chrome bundle '${this.bundleId}' version '${chromeVersion}'`);
+            const matchingDrivers = cds.filter(({ minChromeVersion }) => {
+                const minChromeVersionS = minChromeVersion && semver_1.default.coerce(minChromeVersion);
+                if (!minChromeVersionS) {
+                    return false;
+                }
+                return chromeVersion.major > NEW_CD_VERSION_FORMAT_MAJOR_VERSION
+                    ? minChromeVersionS.major === chromeVersion.major
+                    : semver_1.default.gte(chromeVersion, minChromeVersionS);
+            });
+            if (lodash_1.default.isEmpty(matchingDrivers)) {
+                if (this.storageClient && !didStorageSync) {
+                    try {
+                        if (await syncChromedrivers(chromeVersion)) {
+                            continue;
+                        }
+                    }
+                    catch (e) {
+                        const err = /** @type {Error} */ (e);
+                        this.log.warn(`Cannot synchronize local chromedrivers with the remote storage at ${utils_1.CD_CDN}: ` +
+                            err.message);
+                        this.log.debug(err.stack);
+                    }
+                }
+                const autodownloadSuggestion = 'You could also try to enable automated chromedrivers download as ' +
+                    'a possible workaround.';
+                throw new Error(`No Chromedriver found that can automate Chrome '${chromeVersion}'.` +
+                    (this.storageClient ? '' : ` ${autodownloadSuggestion}`));
+            }
+            const binPath = matchingDrivers[0].executable;
+            this.log.debug(`Found ${support_1.util.pluralize('executable', matchingDrivers.length, true)} ` +
+                `capable of automating Chrome '${chromeVersion}'.\nChoosing the most recent, '${binPath}'.`);
+            this.log.debug('If a specific version is required, specify it with the `chromedriverExecutable`' +
+                'desired capability.');
+            return binPath;
+            // eslint-disable-next-line no-constant-condition
+        } while (true);
+    }
+    async initChromedriverPath() {
+        if (this.executableVerified && this.chromedriver) {
+            return /** @type {string} */ (this.chromedriver);
+        }
+        let chromedriver = this.chromedriver;
+        // the executable might be set (if passed in)
+        // or we might want to use the basic one installed with this driver
+        // or we want to figure out the best one
+        if (!chromedriver) {
+            chromedriver = this.chromedriver = this.useSystemExecutable
+                ? await (0, utils_1.getChromedriverBinaryPath)()
+                : await this.getCompatibleChromedriver();
+        }
+        if (!(await support_1.fs.exists(chromedriver))) {
+            throw new Error(`Trying to use a chromedriver binary at the path ` +
+                `${this.chromedriver}, but it doesn't exist!`);
+        }
+        this.executableVerified = true;
+        this.log.info(`Set chromedriver binary as: ${this.chromedriver}`);
+        return /** @type {string} */ (this.chromedriver);
+    }
+    /**
+     *
+     * @param {string} [cdVersion]
+     */
+    syncProtocol(cdVersion) {
+        const coercedVersion = semver_1.default.coerce(cdVersion);
+        if (!coercedVersion || coercedVersion.major < MIN_CD_VERSION_WITH_W3C_SUPPORT) {
+            this.log.debug(`Chromedriver v. ${cdVersion} does not fully support ${base_driver_1.PROTOCOLS.W3C} protocol. ` +
+                `Defaulting to ${base_driver_1.PROTOCOLS.MJSONWP}`);
+            return;
+        }
+        const chromeOptions = (0, protocol_helpers_1.getCapValue)(this.capabilities, 'chromeOptions', {});
+        if (chromeOptions.w3c === false) {
+            this.log.info(`Chromedriver v. ${cdVersion} supports ${base_driver_1.PROTOCOLS.W3C} protocol, ` +
+                `but ${base_driver_1.PROTOCOLS.MJSONWP} one has been explicitly requested`);
+            return;
+        }
+        this.desiredProtocol = base_driver_1.PROTOCOLS.W3C;
+        // given caps might not be properly prefixed
+        // so we try to fix them in order to properly init
+        // the new W3C session
+        this.capabilities = (0, protocol_helpers_1.toW3cCapNames)(this.capabilities);
+    }
+    /**
+     *
+     * @param {object} caps
+     * @param {boolean} emitStartingState
+     */
+    async start(caps, emitStartingState = true) {
+        this.capabilities = lodash_1.default.cloneDeep(caps);
+        // set the logging preferences to ALL the console logs
+        this.capabilities.loggingPrefs = lodash_1.default.cloneDeep((0, protocol_helpers_1.getCapValue)(caps, 'loggingPrefs', {}));
+        if (lodash_1.default.isEmpty(this.capabilities.loggingPrefs.browser)) {
+            this.capabilities.loggingPrefs.browser = 'ALL';
+        }
+        if (emitStartingState) {
+            this.changeState(Chromedriver.STATE_STARTING);
+        }
+        const args = [`--port=${this.proxyPort}`];
+        if (this.adb && this.adb.adbPort) {
+            args.push(`--adb-port=${this.adb.adbPort}`);
+        }
+        if (lodash_1.default.isArray(this.cmdArgs)) {
+            args.push(...this.cmdArgs);
+        }
+        if (this.logPath) {
+            args.push(`--log-path=${this.logPath}`);
+        }
+        if (this.disableBuildCheck) {
+            args.push('--disable-build-check');
+        }
+        args.push('--verbose');
+        // what are the process stdout/stderr conditions wherein we know that
+        // the process has started to our satisfaction?
+        const startDetector = /** @param {string} stdout */ (stdout) => stdout.startsWith('Starting ');
+        let processIsAlive = false;
+        let webviewVersion;
+        try {
+            const chromedriverPath = await this.initChromedriverPath();
+            await this.killAll();
+            // set up our subprocess object
+            this.proc = new teen_process_1.SubProcess(chromedriverPath, args);
+            processIsAlive = true;
+            // handle log output
+            this.proc.on('output', (stdout, stderr) => {
+                // if the cd output is not printed, find the chrome version and print
+                // will get a response like
+                //   DevTools response: {
+                //      "Android-Package": "io.appium.sampleapp",
+                //      "Browser": "Chrome/55.0.2883.91",
+                //      "Protocol-Version": "1.2",
+                //      "User-Agent": "...",
+                //      "WebKit-Version": "537.36"
+                //   }
+                const out = stdout + stderr;
+                let match = /"Browser": "(.*)"/.exec(out);
+                if (match) {
+                    webviewVersion = match[1];
+                    this.log.debug(`Webview version: '${webviewVersion}'`);
+                }
+                // also print chromedriver version to logs
+                // will output something like
+                //  Starting ChromeDriver 2.33.506106 (8a06c39c4582fbfbab6966dbb1c38a9173bfb1a2) on port 9515
+                match = /Starting ChromeDriver ([.\d]+)/.exec(out);
+                if (match) {
+                    this.log.debug(`Chromedriver version: '${match[1]}'`);
+                    this.syncProtocol(match[1]);
+                }
+                // give the output if it is requested
+                if (this.verbose) {
+                    for (let line of (stdout || '').trim().split('\n')) {
+                        if (!line.trim().length)
+                            continue; // eslint-disable-line curly
+                        this.log.debug(`[STDOUT] ${line}`);
+                    }
+                    for (let line of (stderr || '').trim().split('\n')) {
+                        if (!line.trim().length)
+                            continue; // eslint-disable-line curly
+                        this.log.error(`[STDERR] ${line}`);
+                    }
+                }
+            });
+            // handle out-of-bound exit by simply emitting a stopped state
+            this.proc.on('exit', (code, signal) => {
+                processIsAlive = false;
+                if (this.state !== Chromedriver.STATE_STOPPED &&
+                    this.state !== Chromedriver.STATE_STOPPING &&
+                    this.state !== Chromedriver.STATE_RESTARTING) {
+                    const msg = `Chromedriver exited unexpectedly with code ${code}, signal ${signal}`;
+                    this.log.error(msg);
+                    this.changeState(Chromedriver.STATE_STOPPED);
+                }
+            });
+            this.log.info(`Spawning chromedriver with: ${this.chromedriver} ${args.join(' ')}`);
+            // start subproc and wait for startDetector
+            await this.proc.start(startDetector);
+            await this.waitForOnline();
+            await this.startSession();
+        }
+        catch (e) {
+            const err = /** @type {Error} */ (e);
+            this.log.debug(err);
+            this.emit(Chromedriver.EVENT_ERROR, err);
+            // just because we had an error doesn't mean the chromedriver process
+            // finished; we should clean up if necessary
+            if (processIsAlive) {
+                await this.proc?.stop();
+            }
+            let message = '';
+            // often the user's Chrome version is not supported by the version of Chromedriver
+            if (err.message.includes('Chrome version must be')) {
+                message +=
+                    'Unable to automate Chrome version because it is not supported by this version of Chromedriver.\n';
+                if (webviewVersion) {
+                    message += `Chrome version on the device: ${webviewVersion}\n`;
+                }
+                const versionsSupportedByDriver = /Chrome version must be (.+)/.exec(err.message)?.[1] || '';
+                if (versionsSupportedByDriver) {
+                    message += `Chromedriver supports Chrome version(s): ${versionsSupportedByDriver}\n`;
+                }
+                message += 'Check the driver tutorial for troubleshooting.\n';
+            }
+            message += err.message;
+            this.log.errorAndThrow(message);
+        }
     }
-  }
-  async getStatus() {
-    return await this.jwproxy.command('/status', 'GET');
-  }
-  async startSession() {
-    const sessionCaps = this.desiredProtocol === _baseDriver.PROTOCOLS.W3C ? {
-      capabilities: {
-        alwaysMatch: this.capabilities
-      }
-    } : {
-      desiredCapabilities: this.capabilities
-    };
-    this.log.info(`Starting ${this.desiredProtocol} Chromedriver session with capabilities: ` + JSON.stringify(sessionCaps, null, 2));
-    await this.jwproxy.command('/session', 'POST', sessionCaps);
-    this.log.prefix = (0, _utils.generateLogPrefix)(this, this.jwproxy.sessionId);
-    this.changeState(Chromedriver.STATE_ONLINE);
-  }
-  async stop(emitStates = true) {
-    if (emitStates) {
-      this.changeState(Chromedriver.STATE_STOPPING);
+    sessionId() {
+        return this.state === Chromedriver.STATE_ONLINE ? this.jwproxy.sessionId : null;
     }
-    const runSafeStep = async f => {
-      try {
-        return await f();
-      } catch (e) {
-        this.log.warn(e.message);
-        this.log.debug(e.stack);
-      }
-    };
-    await runSafeStep(() => this.jwproxy.command('', 'DELETE'));
-    await runSafeStep(() => this.proc.stop('SIGTERM', 20000));
-    this.log.prefix = (0, _utils.generateLogPrefix)(this);
-    if (emitStates) {
-      this.changeState(Chromedriver.STATE_STOPPED);
+    async restart() {
+        this.log.info('Restarting chromedriver');
+        if (this.state !== Chromedriver.STATE_ONLINE) {
+            throw new Error("Can't restart when we're not online");
+        }
+        this.changeState(Chromedriver.STATE_RESTARTING);
+        await this.stop(false);
+        await this.start(this.capabilities, false);
+    }
+    async waitForOnline() {
+        // we need to make sure that CD hasn't crashed
+        let chromedriverStopped = false;
+        await (0, asyncbox_1.retryInterval)(20, 200, async () => {
+            if (this.state === Chromedriver.STATE_STOPPED) {
+                // we are either stopped or stopping, so something went wrong
+                chromedriverStopped = true;
+                return;
+            }
+            await this.getStatus();
+        });
+        if (chromedriverStopped) {
+            throw new Error('ChromeDriver crashed during startup.');
+        }
     }
-  }
-  changeState(state) {
-    this.state = state;
-    this.log.debug(`Changed state to '${state}'`);
-    this.emit(Chromedriver.EVENT_CHANGED, {
-      state
-    });
-  }
-  async sendCommand(url, method, body) {
-    return await this.jwproxy.command(url, method, body);
-  }
-  async proxyReq(req, res) {
-    return await this.jwproxy.proxyReqRes(req, res);
-  }
-  async killAll() {
-    let cmd = _support.system.isWindows() ? `wmic process where "commandline like '%chromedriver.exe%--port=${this.proxyPort}%'" delete` : `pkill -15 -f "${this.chromedriver}.*--port=${this.proxyPort}"`;
-    this.log.debug(`Killing any old chromedrivers, running: ${cmd}`);
-    try {
-      await _bluebird.default.promisify(_child_process.default.exec)(cmd);
-      this.log.debug('Successfully cleaned up old chromedrivers');
-    } catch (err) {
-      this.log.warn('No old chromedrivers seem to exist');
+    async getStatus() {
+        return await this.jwproxy.command('/status', 'GET');
+    }
+    async startSession() {
+        const sessionCaps = this.desiredProtocol === base_driver_1.PROTOCOLS.W3C
+            ? { capabilities: { alwaysMatch: this.capabilities } }
+            : { desiredCapabilities: this.capabilities };
+        this.log.info(`Starting ${this.desiredProtocol} Chromedriver session with capabilities: ` +
+            JSON.stringify(sessionCaps, null, 2));
+        // jwproxy types have not been implemented yet
+        // @ts-expect-error
+        await this.jwproxy.command('/session', 'POST', sessionCaps);
+        this.log.prefix = (0, utils_1.generateLogPrefix)(this, this.jwproxy.sessionId);
+        this.changeState(Chromedriver.STATE_ONLINE);
+    }
+    async stop(emitStates = true) {
+        if (emitStates) {
+            this.changeState(Chromedriver.STATE_STOPPING);
+        }
+        /**
+         *
+         * @param {() => Promise<any>|any} f
+         */
+        const runSafeStep = async (f) => {
+            try {
+                return await f();
+            }
+            catch (e) {
+                const err = /** @type {Error} */ (e);
+                this.log.warn(err.message);
+                this.log.debug(err.stack);
+            }
+        };
+        await runSafeStep(() => this.jwproxy.command('', 'DELETE'));
+        await runSafeStep(() => this.proc?.stop('SIGTERM', 20000));
+        this.log.prefix = (0, utils_1.generateLogPrefix)(this);
+        if (emitStates) {
+            this.changeState(Chromedriver.STATE_STOPPED);
+        }
     }
-    if (this.adb) {
-      const udidIndex = this.adb.executable.defaultArgs.findIndex(item => item === '-s');
-      const udid = udidIndex > -1 ? this.adb.executable.defaultArgs[udidIndex + 1] : null;
-      if (udid) {
-        this.log.debug(`Cleaning this device's adb forwarded port socket connections: ${udid}`);
-      } else {
-        this.log.debug(`Cleaning any old adb forwarded port socket connections`);
-      }
-      try {
-        for (let conn of await this.adb.getForwardList()) {
-          if (!(conn.includes('webview_devtools') && (!udid || conn.includes(udid)))) {
-            continue;
-          }
-          let params = conn.split(/\s+/);
-          if (params.length > 1) {
-            await this.adb.removePortForward(params[1].replace(/[\D]*/, ''));
-          }
-        }
-      } catch (err) {
-        this.log.warn(`Unable to clean forwarded ports. Error: '${err.message}'. Continuing.`);
-      }
+    /**
+     *
+     * @param {string} state
+     */
+    changeState(state) {
+        this.state = state;
+        this.log.debug(`Changed state to '${state}'`);
+        this.emit(Chromedriver.EVENT_CHANGED, { state });
+    }
+    /**
+     *
+     * @param {string} url
+     * @param {'POST'|'GET'|'DELETE'} method
+     * @param {any} body
+     * @returns
+     */
+    async sendCommand(url, method, body) {
+        return await this.jwproxy.command(url, method, body);
+    }
+    /**
+     *
+     * @param {any} req
+     * @param {any} res
+     * @privateRemarks req / res probably from Express
+     */
+    async proxyReq(req, res) {
+        return await this.jwproxy.proxyReqRes(req, res);
+    }
+    async killAll() {
+        let cmd = support_1.system.isWindows()
+            ? `wmic process where "commandline like '%chromedriver.exe%--port=${this.proxyPort}%'" delete`
+            : `pkill -15 -f "${this.chromedriver}.*--port=${this.proxyPort}"`;
+        this.log.debug(`Killing any old chromedrivers, running: ${cmd}`);
+        try {
+            await bluebird_1.default.promisify(child_process_1.default.exec)(cmd);
+            this.log.debug('Successfully cleaned up old chromedrivers');
+        }
+        catch (err) {
+            this.log.warn('No old chromedrivers seem to exist');
+        }
+        if (this.adb) {
+            const udidIndex = this.adb.executable.defaultArgs.findIndex((item) => item === '-s');
+            const udid = udidIndex > -1 ? this.adb.executable.defaultArgs[udidIndex + 1] : null;
+            if (udid) {
+                this.log.debug(`Cleaning this device's adb forwarded port socket connections: ${udid}`);
+            }
+            else {
+                this.log.debug(`Cleaning any old adb forwarded port socket connections`);
+            }
+            try {
+                for (let conn of await this.adb.getForwardList()) {
+                    // chromedriver will ask ADB to forward a port like "deviceId tcp:port localabstract:webview_devtools_remote_port"
+                    if (!(conn.includes('webview_devtools') && (!udid || conn.includes(udid)))) {
+                        continue;
+                    }
+                    let params = conn.split(/\s+/);
+                    if (params.length > 1) {
+                        await this.adb.removePortForward(params[1].replace(/[\D]*/, ''));
+                    }
+                }
+            }
+            catch (e) {
+                const err = /** @type {Error} */ (e);
+                this.log.warn(`Unable to clean forwarded ports. Error: '${err.message}'. Continuing.`);
+            }
+        }
     }
-  }
-  async hasWorkingWebview() {
-    try {
-      await this.jwproxy.command('/url', 'GET');
-      return true;
-    } catch (e) {
-      return false;
+    async hasWorkingWebview() {
+        // sometimes chromedriver stops automating webviews. this method runs a
+        // simple command to determine our state, and responds accordingly
+        try {
+            await this.jwproxy.command('/url', 'GET');
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
     }
-  }
 }
 exports.Chromedriver = Chromedriver;
 Chromedriver.EVENT_ERROR = 'chromedriver_error';
@@ -582,6 +706,8 @@ Chromedriver.STATE_STARTING = 'starting';
 Chromedriver.STATE_ONLINE = 'online';
 Chromedriver.STATE_STOPPING = 'stopping';
 Chromedriver.STATE_RESTARTING = 'restarting';
-var _default = Chromedriver;
-exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["NEW_CD_VERSION_FORMAT_MAJOR_VERSION","DEFAULT_HOST","MIN_CD_VERSION_WITH_W3C_SUPPORT","DEFAULT_PORT","CHROME_BUNDLE_ID","WEBVIEW_SHELL_BUNDLE_ID","WEBVIEW_BUNDLE_IDS","VERSION_PATTERN","CD_VERSION_TIMEOUT","Chromedriver","events","EventEmitter","constructor","args","host","port","useSystemExecutable","executable","executableDir","getChromedriverDir","bundleId","mappingPath","cmdArgs","adb","verbose","logPath","disableBuildCheck","details","isAutodownloadEnabled","_log","logger","getLogger","generateLogPrefix","proxyHost","proxyPort","proc","chromedriver","executableVerified","state","STATE_STOPPED","jwproxy","JWProxy","server","log","storageClient","ChromedriverStorageClient","chromedriverDir","capabilities","desiredProtocol","PROTOCOLS","MJSONWP","getDriversMapping","mapping","_","cloneDeep","CHROMEDRIVER_CHROME_MAPPING","debug","fs","exists","warn","info","JSON","parse","readFile","err","message","cdVersion","chromeVersion","toPairs","coercedVersion","semver","coerce","version","getChromedrivers","executables","glob","cwd","strict","nodir","absolute","util","pluralize","length","cds","asyncmap","logError","stdout","stderr","errMsg","path","basename","exec","timeout","includes","match","minChromeVersion","major","minor","filter","cd","sort","a","b","compareVersions","isEmpty","getChromeVersion","Browser","versionMatch","apiLevel","getApiLevel","updateDriversMapping","newMapping","shouldUpdateStaticMapping","writeFile","stringify","e","Object","assign","getCompatibleChromedriver","getChromedriverBinaryPath","values","didStorageSync","syncChromedrivers","retrievedMapping","retrieveMapping","driverKeys","syncDrivers","minBrowserVersion","synchronizedDriversMapping","reduce","acc","x","missingVersions","coercedVer","size","errorAndThrow","matchingDrivers","minChromeVersionS","gte","CD_CDN","stack","autodownloadSuggestion","Error","binPath","initChromedriverPath","syncProtocol","W3C","chromeOptions","getCapValue","w3c","toW3cCapNames","start","caps","emitStartingState","loggingPrefs","browser","changeState","STATE_STARTING","adbPort","push","isArray","startDetector","startsWith","processIsAlive","webviewVersion","killAll","SubProcess","on","out","line","trim","split","error","code","signal","STATE_STOPPING","STATE_RESTARTING","msg","join","waitForOnline","startSession","emit","EVENT_ERROR","stop","versionsSupportedByDriver","sessionId","STATE_ONLINE","restart","chromedriverStopped","retryInterval","getStatus","command","sessionCaps","alwaysMatch","desiredCapabilities","prefix","emitStates","runSafeStep","f","EVENT_CHANGED","sendCommand","url","method","body","proxyReq","req","res","proxyReqRes","cmd","system","isWindows","B","promisify","cp","udidIndex","defaultArgs","findIndex","item","udid","conn","getForwardList","params","removePortForward","replace","hasWorkingWebview"],"sources":["../../lib/chromedriver.js"],"sourcesContent":["// transpile:main\n\nimport events from 'events';\nimport { JWProxy, PROTOCOLS } from '@appium/base-driver';\nimport cp from 'child_process';\nimport { system, fs, logger, util } from '@appium/support';\nimport { retryInterval, asyncmap } from 'asyncbox';\nimport { SubProcess, exec } from 'teen_process';\nimport B from 'bluebird';\nimport {\n  getChromeVersion, getChromedriverDir, CHROMEDRIVER_CHROME_MAPPING,\n  getChromedriverBinaryPath, CD_CDN, generateLogPrefix\n} from './utils';\nimport semver from 'semver';\nimport _ from 'lodash';\nimport path from 'path';\nimport { compareVersions } from 'compare-versions';\nimport ChromedriverStorageClient from './storage-client';\nimport { toW3cCapNames, getCapValue } from './protocol-helpers';\n\nconst NEW_CD_VERSION_FORMAT_MAJOR_VERSION = 73;\nconst DEFAULT_HOST = '127.0.0.1';\nconst MIN_CD_VERSION_WITH_W3C_SUPPORT = 75;\nconst DEFAULT_PORT = 9515;\nconst CHROME_BUNDLE_ID = 'com.android.chrome';\nconst WEBVIEW_SHELL_BUNDLE_ID = 'org.chromium.webview_shell';\nconst WEBVIEW_BUNDLE_IDS = [\n  'com.google.android.webview',\n  'com.android.webview',\n];\nconst VERSION_PATTERN = /([\\d.]+)/;\n\nconst CD_VERSION_TIMEOUT = 5000;\n\nclass Chromedriver extends events.EventEmitter {\n  constructor (args = {}) {\n    super();\n\n    const {\n      host = DEFAULT_HOST,\n      port = DEFAULT_PORT,\n      useSystemExecutable = false,\n      executable,\n      executableDir = getChromedriverDir(),\n      bundleId,\n      mappingPath,\n      cmdArgs,\n      adb,\n      verbose,\n      logPath,\n      disableBuildCheck,\n      details,\n      isAutodownloadEnabled = false,\n    } = args;\n    this._log = logger.getLogger(generateLogPrefix(this));\n\n    this.proxyHost = host;\n    this.proxyPort = port;\n    this.adb = adb;\n    this.cmdArgs = cmdArgs;\n    this.proc = null;\n    this.useSystemExecutable = useSystemExecutable;\n    this.chromedriver = executable;\n    this.executableDir = executableDir;\n    this.mappingPath = mappingPath;\n    this.bundleId = bundleId;\n    this.executableVerified = false;\n    this.state = Chromedriver.STATE_STOPPED;\n    this.jwproxy = new JWProxy({\n      server: this.proxyHost,\n      port: this.proxyPort,\n      log: this._log,\n    });\n    this.verbose = verbose;\n    this.logPath = logPath;\n    this.disableBuildCheck = !!disableBuildCheck;\n    this.storageClient = isAutodownloadEnabled\n      ? new ChromedriverStorageClient({ chromedriverDir: this.executableDir })\n      : null;\n    this.details = details;\n    this.capabilities = {};\n    this.desiredProtocol = PROTOCOLS.MJSONWP;\n  }\n\n  get log () {\n    return this._log;\n  }\n\n  async getDriversMapping () {\n    let mapping = _.cloneDeep(CHROMEDRIVER_CHROME_MAPPING);\n    if (this.mappingPath) {\n      this.log.debug(`Attempting to use Chromedriver->Chrome mapping from '${this.mappingPath}'`);\n      if (!await fs.exists(this.mappingPath)) {\n        this.log.warn(`No file found at '${this.mappingPath}'`);\n        this.log.info('Defaulting to the static Chromedriver->Chrome mapping');\n      } else {\n        try {\n          mapping = JSON.parse(await fs.readFile(this.mappingPath, 'utf8'));\n        } catch (err) {\n          this.log.warn(`Error parsing mapping from '${this.mappingPath}': ${err.message}`);\n          this.log.info('Defaulting to the static Chromedriver->Chrome mapping');\n        }\n      }\n    } else {\n      this.log.debug('Using the static Chromedriver->Chrome mapping');\n    }\n\n    // make sure that the values for minimum chrome version are semver compliant\n    for (const [cdVersion, chromeVersion] of _.toPairs(mapping)) {\n      const coercedVersion = semver.coerce(chromeVersion);\n      if (coercedVersion) {\n        mapping[cdVersion] = coercedVersion.version;\n      } else {\n        this.log.info(`'${chromeVersion}' is not a valid version number. Skipping it`);\n      }\n    }\n    return mapping;\n  }\n\n  async getChromedrivers (mapping) {\n    // go through the versions available\n    const executables = await fs.glob('*', {\n      cwd: this.executableDir,\n      strict: false,\n      nodir: true,\n      absolute: true,\n    });\n    this.log.debug(`Found ${util.pluralize('executable', executables.length, true)} ` +\n      `in '${this.executableDir}'`);\n    const cds = (await asyncmap(executables, async (executable) => {\n      const logError = ({message, stdout = null, stderr = null}) => {\n        let errMsg = `Cannot retrieve version number from '${path.basename(executable)}' Chromedriver binary. ` +\n          `Make sure it returns a valid version string in response to '--version' command line argument. ${message}`;\n        if (stdout) {\n          errMsg += `\\nStdout: ${stdout}`;\n        }\n        if (stderr) {\n          errMsg += `\\nStderr: ${stderr}`;\n        }\n        this.log.warn(errMsg);\n        return null;\n      };\n\n      let stdout;\n      let stderr;\n      try {\n        ({stdout, stderr} = await exec(executable, ['--version'], {\n          timeout: CD_VERSION_TIMEOUT,\n        }));\n      } catch (err) {\n        if (!(err.message || '').includes('timed out') && !(err.stdout || '').includes('Starting ChromeDriver')) {\n          return logError(err);\n        }\n\n        // if this has timed out, it has actually started Chromedriver,\n        // in which case there will also be the version string in the output\n        stdout = err.stdout;\n      }\n\n      const match = /ChromeDriver\\s+\\(?v?([\\d.]+)\\)?/i.exec(stdout); // https://regex101.com/r/zpj5wA/1\n      if (!match) {\n        return logError({message: 'Cannot parse the version string', stdout, stderr});\n      }\n      let version = match[1];\n      let minChromeVersion = mapping[version];\n      const coercedVersion = semver.coerce(version);\n      if (coercedVersion) {\n        // before 2019-03-06 versions were of the form major.minor\n        if (coercedVersion.major < NEW_CD_VERSION_FORMAT_MAJOR_VERSION) {\n          version = `${coercedVersion.major}.${coercedVersion.minor}`;\n          minChromeVersion = mapping[version];\n        }\n        if (!minChromeVersion && coercedVersion.major >= NEW_CD_VERSION_FORMAT_MAJOR_VERSION) {\n          // Assume the major Chrome version is the same as the corresponding driver major version\n          minChromeVersion = `${coercedVersion.major}`;\n        }\n      }\n      return {\n        executable,\n        version,\n        minChromeVersion,\n      };\n    }))\n      .filter((cd) => !!cd)\n      .sort((a, b) => compareVersions(b.version, a.version));\n    if (_.isEmpty(cds)) {\n      this.log.info(`No Chromedrivers were found in '${this.executableDir}'`);\n      return cds;\n    }\n    this.log.debug(`The following Chromedriver executables were found:`);\n    for (const cd of cds) {\n      this.log.debug(`    '${cd.executable}' (version '${cd.version}', minimum Chrome version '${cd.minChromeVersion ? cd.minChromeVersion : 'Unknown'}')`);\n    }\n    return cds;\n  }\n\n  async getChromeVersion () {\n    // Try to retrieve the version from `details` property if it is set\n    // The `info` item must contain the output of /json/version CDP command\n    // where `Browser` field looks like `Chrome/72.0.3601.0``\n    if (this.details?.info) {\n      this.log.debug(`Browser version in the supplied details: ${this.details?.info?.Browser}`);\n    }\n    const versionMatch = VERSION_PATTERN.exec(this.details?.info?.Browser);\n    if (versionMatch) {\n      const coercedVersion = semver.coerce(versionMatch[1]);\n      if (coercedVersion) {\n        return coercedVersion;\n      }\n    }\n\n    let chromeVersion;\n\n    // in case of WebView Browser Tester, simply try to find the underlying webview\n    if (this.bundleId === WEBVIEW_SHELL_BUNDLE_ID) {\n      for (const bundleId of WEBVIEW_BUNDLE_IDS) {\n        chromeVersion = await getChromeVersion(this.adb, bundleId);\n        if (chromeVersion) {\n          this.bundleId = bundleId;\n          return semver.coerce(chromeVersion);\n        }\n      }\n      return null;\n    }\n\n    // on Android 7-9 webviews are backed by the main Chrome, not the system webview\n    if (this.adb) {\n      const apiLevel = await this.adb.getApiLevel();\n      if (apiLevel >= 24 && apiLevel <= 28 &&\n          [WEBVIEW_SHELL_BUNDLE_ID, ...WEBVIEW_BUNDLE_IDS].includes(this.bundleId)) {\n        this.bundleId = CHROME_BUNDLE_ID;\n      }\n    }\n\n    // try out webviews when no bundle id is sent in\n    if (!this.bundleId) {\n      // default to the generic Chrome bundle\n      this.bundleId = CHROME_BUNDLE_ID;\n\n      // we have a webview of some sort, so try to find the bundle version\n      for (const bundleId of WEBVIEW_BUNDLE_IDS) {\n        chromeVersion = await getChromeVersion(this.adb, bundleId);\n        if (chromeVersion) {\n          this.bundleId = bundleId;\n          break;\n        }\n      }\n    }\n\n    // if we do not have a chrome version, it must not be a webview\n    if (!chromeVersion) {\n      chromeVersion = await getChromeVersion(this.adb, this.bundleId);\n    }\n\n    // make sure it is semver, so later checks won't fail\n    return chromeVersion ? semver.coerce(chromeVersion) : null;\n  }\n\n  async updateDriversMapping (newMapping) {\n    let shouldUpdateStaticMapping = true;\n    if (await fs.exists(this.mappingPath)) {\n      try {\n        await fs.writeFile(this.mappingPath, JSON.stringify(newMapping, null, 2), 'utf8');\n        shouldUpdateStaticMapping = false;\n      } catch (e) {\n        this.log.warn(`Cannot store the updated chromedrivers mapping into '${this.mappingPath}'. ` +\n          `This may reduce the performance of further executions. Original error: ${e.message}`);\n      }\n    }\n    if (shouldUpdateStaticMapping) {\n      Object.assign(CHROMEDRIVER_CHROME_MAPPING, newMapping);\n    }\n  }\n\n  async getCompatibleChromedriver () {\n    if (!this.adb) {\n      return await getChromedriverBinaryPath();\n    }\n\n    const mapping = await this.getDriversMapping();\n    if (!_.isEmpty(mapping)) {\n      this.log.debug(`The most recent known Chrome version: ${_.values(mapping)[0]}`);\n    }\n\n    let didStorageSync = false;\n    const syncChromedrivers = async (chromeVersion) => {\n      didStorageSync = true;\n      const retrievedMapping = await this.storageClient.retrieveMapping();\n      this.log.debug('Got chromedrivers mapping from the storage: ' +\n        JSON.stringify(retrievedMapping, null, 2));\n      const driverKeys = await this.storageClient.syncDrivers({\n        minBrowserVersion: chromeVersion.major,\n      });\n      if (_.isEmpty(driverKeys)) {\n        return false;\n      }\n      const synchronizedDriversMapping = driverKeys.reduce((acc, x) => {\n        const {version, minBrowserVersion} = retrievedMapping[x];\n        acc[version] = minBrowserVersion;\n        return acc;\n      }, {});\n      Object.assign(mapping, synchronizedDriversMapping);\n      await this.updateDriversMapping(mapping);\n      return true;\n    };\n\n    do {\n      const cds = await this.getChromedrivers(mapping);\n\n      const missingVersions = {};\n      for (const {version, minChromeVersion} of cds) {\n        if (!minChromeVersion || mapping[version]) {\n          continue;\n        }\n        const coercedVer = semver.coerce(version);\n        if (!coercedVer || coercedVer.major < NEW_CD_VERSION_FORMAT_MAJOR_VERSION) {\n          continue;\n        }\n\n        missingVersions[version] = minChromeVersion;\n      }\n      if (!_.isEmpty(missingVersions)) {\n        this.log.info(`Found ${util.pluralize('Chromedriver', _.size(missingVersions), true)}, ` +\n          `which ${_.size(missingVersions) === 1 ? 'is' : 'are'} missing in the list of known versions: ` +\n          JSON.stringify(missingVersions));\n        await this.updateDriversMapping(Object.assign(mapping, missingVersions));\n      }\n\n      if (this.disableBuildCheck) {\n        if (_.isEmpty(cds)) {\n          this.log.errorAndThrow(`There must be at least one Chromedriver executable available for use if ` +\n            `'chromedriverDisableBuildCheck' capability is set to 'true'`);\n        }\n        const {version, executable} = cds[0];\n        this.log.warn(`Chrome build check disabled. Using most recent Chromedriver version (${version}, at '${executable}')`);\n        this.log.warn(`If this is wrong, set 'chromedriverDisableBuildCheck' capability to 'false'`);\n        return executable;\n      }\n\n      const chromeVersion = await this.getChromeVersion();\n      if (!chromeVersion) {\n        // unable to get the chrome version\n        if (_.isEmpty(cds)) {\n          this.log.errorAndThrow(`There must be at least one Chromedriver executable available for use if ` +\n            `the current Chrome version cannot be determined`);\n        }\n        const {version, executable} = cds[0];\n        this.log.warn(`Unable to discover Chrome version. Using Chromedriver ${version} at '${executable}'`);\n        return executable;\n      }\n      this.log.debug(`Found Chrome bundle '${this.bundleId}' version '${chromeVersion}'`);\n\n      const matchingDrivers = cds.filter(({minChromeVersion}) => {\n        const minChromeVersionS = minChromeVersion && semver.coerce(minChromeVersion);\n        if (!minChromeVersionS) {\n          return false;\n        }\n\n        return chromeVersion.major > NEW_CD_VERSION_FORMAT_MAJOR_VERSION\n          ? minChromeVersionS.major === chromeVersion.major\n          : semver.gte(chromeVersion, minChromeVersionS);\n      });\n      if (_.isEmpty(matchingDrivers)) {\n        if (this.storageClient && !didStorageSync) {\n          try {\n            if (await syncChromedrivers(chromeVersion)) {\n              continue;\n            }\n          } catch (e) {\n            this.log.warn(`Cannot synchronize local chromedrivers with the remote storage at ${CD_CDN}: ` +\n              e.message);\n            this.log.debug(e.stack);\n          }\n        }\n        const autodownloadSuggestion =\n          'You could also try to enable automated chromedrivers download as ' +\n          'a possible workaround.';\n        throw new Error(`No Chromedriver found that can automate Chrome '${chromeVersion}'.` +\n          (this.storageClient ? '' : ` ${autodownloadSuggestion}`));\n      }\n\n      const binPath = matchingDrivers[0].executable;\n      this.log.debug(`Found ${util.pluralize('executable', matchingDrivers.length, true)} ` +\n        `capable of automating Chrome '${chromeVersion}'.\\nChoosing the most recent, '${binPath}'.`);\n      this.log.debug('If a specific version is required, specify it with the `chromedriverExecutable`' +\n        'desired capability.');\n      return binPath;\n    // eslint-disable-next-line no-constant-condition\n    } while (true);\n  }\n\n  async initChromedriverPath () {\n    if (this.executableVerified) return; //eslint-disable-line curly\n\n    // the executable might be set (if passed in)\n    // or we might want to use the basic one installed with this driver\n    // or we want to figure out the best one\n    if (!this.chromedriver) {\n      this.chromedriver = this.useSystemExecutable\n        ? await getChromedriverBinaryPath()\n        : await this.getCompatibleChromedriver();\n    }\n\n    if (!await fs.exists(this.chromedriver)) {\n      throw new Error(`Trying to use a chromedriver binary at the path ` +\n                      `${this.chromedriver}, but it doesn't exist!`);\n    }\n    this.executableVerified = true;\n    this.log.info(`Set chromedriver binary as: ${this.chromedriver}`);\n  }\n\n  syncProtocol (cdVersion = null) {\n    const coercedVersion = semver.coerce(cdVersion);\n    if (!coercedVersion || coercedVersion.major < MIN_CD_VERSION_WITH_W3C_SUPPORT) {\n      this.log.debug(`Chromedriver v. ${cdVersion} does not fully support ${PROTOCOLS.W3C} protocol. ` +\n        `Defaulting to ${PROTOCOLS.MJSONWP}`);\n      return;\n    }\n    const chromeOptions = getCapValue(this.capabilities, 'chromeOptions', {});\n    if (chromeOptions.w3c === false) {\n      this.log.info(`Chromedriver v. ${cdVersion} supports ${PROTOCOLS.W3C} protocol, ` +\n        `but ${PROTOCOLS.MJSONWP} one has been explicitly requested`);\n      return;\n    }\n    this.desiredProtocol = PROTOCOLS.W3C;\n    // given caps might not be properly prefixed\n    // so we try to fix them in order to properly init\n    // the new W3C session\n    this.capabilities = toW3cCapNames(this.capabilities);\n  }\n\n  async start (caps, emitStartingState = true) {\n    this.capabilities = _.cloneDeep(caps);\n\n    // set the logging preferences to ALL the console logs\n    this.capabilities.loggingPrefs = _.cloneDeep(getCapValue(caps, 'loggingPrefs', {}));\n    if (_.isEmpty(this.capabilities.loggingPrefs.browser)) {\n      this.capabilities.loggingPrefs.browser = 'ALL';\n    }\n\n    if (emitStartingState) {\n      this.changeState(Chromedriver.STATE_STARTING);\n    }\n\n    const args = [`--port=${this.proxyPort}`];\n    if (this.adb && this.adb.adbPort) {\n      args.push(`--adb-port=${this.adb.adbPort}`);\n    }\n    if (_.isArray(this.cmdArgs)) {\n      args.push(...this.cmdArgs);\n    }\n    if (this.logPath) {\n      args.push(`--log-path=${this.logPath}`);\n    }\n    if (this.disableBuildCheck) {\n      args.push('--disable-build-check');\n    }\n    args.push('--verbose');\n    // what are the process stdout/stderr conditions wherein we know that\n    // the process has started to our satisfaction?\n    const startDetector = (stdout) => stdout.startsWith('Starting ');\n\n    let processIsAlive = false;\n    let webviewVersion;\n    try {\n      await this.initChromedriverPath();\n      await this.killAll();\n\n      // set up our subprocess object\n      this.proc = new SubProcess(this.chromedriver, args);\n      processIsAlive = true;\n\n      // handle log output\n      this.proc.on('output', (stdout, stderr) => {\n        // if the cd output is not printed, find the chrome version and print\n        // will get a response like\n        //   DevTools response: {\n        //      \"Android-Package\": \"io.appium.sampleapp\",\n        //      \"Browser\": \"Chrome/55.0.2883.91\",\n        //      \"Protocol-Version\": \"1.2\",\n        //      \"User-Agent\": \"...\",\n        //      \"WebKit-Version\": \"537.36\"\n        //   }\n        const out = stdout + stderr;\n        let match = /\"Browser\": \"(.*)\"/.exec(out);\n        if (match) {\n          webviewVersion = match[1];\n          this.log.debug(`Webview version: '${webviewVersion}'`);\n        }\n\n        // also print chromedriver version to logs\n        // will output something like\n        //  Starting ChromeDriver 2.33.506106 (8a06c39c4582fbfbab6966dbb1c38a9173bfb1a2) on port 9515\n        match = /Starting ChromeDriver ([.\\d]+)/.exec(out);\n        if (match) {\n          this.log.debug(`Chromedriver version: '${match[1]}'`);\n          this.syncProtocol(match[1]);\n        }\n\n        // give the output if it is requested\n        if (this.verbose) {\n          for (let line of (stdout || '').trim().split('\\n')) {\n            if (!line.trim().length) continue; // eslint-disable-line curly\n            this.log.debug(`[STDOUT] ${line}`);\n          }\n          for (let line of (stderr || '').trim().split('\\n')) {\n            if (!line.trim().length) continue; // eslint-disable-line curly\n            this.log.error(`[STDERR] ${line}`);\n          }\n        }\n      });\n\n      // handle out-of-bound exit by simply emitting a stopped state\n      this.proc.on('exit', (code, signal) => {\n        processIsAlive = false;\n        if (this.state !== Chromedriver.STATE_STOPPED &&\n            this.state !== Chromedriver.STATE_STOPPING &&\n            this.state !== Chromedriver.STATE_RESTARTING) {\n          const msg = `Chromedriver exited unexpectedly with code ${code}, signal ${signal}`;\n          this.log.error(msg);\n          this.changeState(Chromedriver.STATE_STOPPED);\n        }\n      });\n      this.log.info(`Spawning chromedriver with: ${this.chromedriver} ${args.join(' ')}`);\n      // start subproc and wait for startDetector\n      await this.proc.start(startDetector);\n      await this.waitForOnline();\n      await this.startSession();\n    } catch (e) {\n      this.log.debug(e);\n      this.emit(Chromedriver.EVENT_ERROR, e);\n      // just because we had an error doesn't mean the chromedriver process\n      // finished; we should clean up if necessary\n      if (processIsAlive) {\n        await this.proc.stop();\n      }\n\n      let message = '';\n      // often the user's Chrome version is not supported by the version of Chromedriver\n      if (e.message.includes('Chrome version must be')) {\n        message += 'Unable to automate Chrome version because it is not supported by this version of Chromedriver.\\n';\n        if (webviewVersion) {\n          message += `Chrome version on the device: ${webviewVersion}\\n`;\n        }\n        const versionsSupportedByDriver = /Chrome version must be (.+)/.exec(e.message)?.[1] || '';\n        if (versionsSupportedByDriver) {\n          message += `Chromedriver supports Chrome version(s): ${versionsSupportedByDriver}\\n`;\n        }\n        message += 'Check the driver tutorial for troubleshooting.\\n';\n      }\n\n      message += e.message;\n      this.log.errorAndThrow(message);\n    }\n  }\n\n  sessionId () {\n    return this.state === Chromedriver.STATE_ONLINE ? this.jwproxy.sessionId : null;\n  }\n\n  async restart () {\n    this.log.info('Restarting chromedriver');\n    if (this.state !== Chromedriver.STATE_ONLINE) {\n      throw new Error(\"Can't restart when we're not online\");\n    }\n    this.changeState(Chromedriver.STATE_RESTARTING);\n    await this.stop(false);\n    await this.start(this.capabilities, false);\n  }\n\n  async waitForOnline () {\n    // we need to make sure that CD hasn't crashed\n    let chromedriverStopped = false;\n    await retryInterval(20, 200, async () => {\n      if (this.state === Chromedriver.STATE_STOPPED) {\n        // we are either stopped or stopping, so something went wrong\n        chromedriverStopped = true;\n        return;\n      }\n      await this.getStatus();\n    });\n    if (chromedriverStopped) {\n      throw new Error('ChromeDriver crashed during startup.');\n    }\n  }\n\n  async getStatus () {\n    return await this.jwproxy.command('/status', 'GET');\n  }\n\n  async startSession () {\n    const sessionCaps = this.desiredProtocol === PROTOCOLS.W3C\n      ? {capabilities: {alwaysMatch: this.capabilities}}\n      : {desiredCapabilities: this.capabilities};\n    this.log.info(`Starting ${this.desiredProtocol} Chromedriver session with capabilities: ` +\n      JSON.stringify(sessionCaps, null, 2));\n    await this.jwproxy.command('/session', 'POST', sessionCaps);\n    this.log.prefix = generateLogPrefix(this, this.jwproxy.sessionId);\n    this.changeState(Chromedriver.STATE_ONLINE);\n  }\n\n  async stop (emitStates = true) {\n    if (emitStates) {\n      this.changeState(Chromedriver.STATE_STOPPING);\n    }\n    const runSafeStep = async (f) => {\n      try {\n        return await f();\n      } catch (e) {\n        this.log.warn(e.message);\n        this.log.debug(e.stack);\n      }\n    };\n    await runSafeStep(() => this.jwproxy.command('', 'DELETE'));\n    await runSafeStep(() => this.proc.stop('SIGTERM', 20000));\n    this.log.prefix = generateLogPrefix(this);\n    if (emitStates) {\n      this.changeState(Chromedriver.STATE_STOPPED);\n    }\n  }\n\n  changeState (state) {\n    this.state = state;\n    this.log.debug(`Changed state to '${state}'`);\n    this.emit(Chromedriver.EVENT_CHANGED, {state});\n  }\n\n  async sendCommand (url, method, body) {\n    return await this.jwproxy.command(url, method, body);\n  }\n\n  async proxyReq (req, res) {\n    return await this.jwproxy.proxyReqRes(req, res);\n  }\n\n  async killAll () {\n    let cmd = system.isWindows()\n      ? `wmic process where \"commandline like '%chromedriver.exe%--port=${this.proxyPort}%'\" delete`\n      : `pkill -15 -f \"${this.chromedriver}.*--port=${this.proxyPort}\"`;\n    this.log.debug(`Killing any old chromedrivers, running: ${cmd}`);\n    try {\n      await (B.promisify(cp.exec))(cmd);\n      this.log.debug('Successfully cleaned up old chromedrivers');\n    } catch (err) {\n      this.log.warn('No old chromedrivers seem to exist');\n    }\n\n    if (this.adb) {\n      const udidIndex = this.adb.executable.defaultArgs.findIndex((item) => item === '-s');\n      const udid = udidIndex > -1 ? this.adb.executable.defaultArgs[udidIndex + 1] : null;\n\n      if (udid) {\n        this.log.debug(`Cleaning this device's adb forwarded port socket connections: ${udid}`);\n      } else {\n        this.log.debug(`Cleaning any old adb forwarded port socket connections`);\n      }\n\n      try {\n        for (let conn of await this.adb.getForwardList()) {\n          // chromedriver will ask ADB to forward a port like \"deviceId tcp:port localabstract:webview_devtools_remote_port\"\n          if (!(conn.includes('webview_devtools') && (!udid || conn.includes(udid)))) {\n            continue;\n          }\n\n          let params = conn.split(/\\s+/);\n          if (params.length > 1) {\n            await this.adb.removePortForward(params[1].replace(/[\\D]*/, ''));\n          }\n        }\n      } catch (err) {\n        this.log.warn(`Unable to clean forwarded ports. Error: '${err.message}'. Continuing.`);\n      }\n    }\n  }\n\n  async hasWorkingWebview () {\n    // sometimes chromedriver stops automating webviews. this method runs a\n    // simple command to determine our state, and responds accordingly\n    try {\n      await this.jwproxy.command('/url', 'GET');\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n}\n\nChromedriver.EVENT_ERROR = 'chromedriver_error';\nChromedriver.EVENT_CHANGED = 'stateChanged';\nChromedriver.STATE_STOPPED = 'stopped';\nChromedriver.STATE_STARTING = 'starting';\nChromedriver.STATE_ONLINE = 'online';\nChromedriver.STATE_STOPPING = 'stopping';\nChromedriver.STATE_RESTARTING = 'restarting';\n\nexport { Chromedriver };\nexport default Chromedriver;\n"],"mappings":"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"}
+exports.default = Chromedriver;
+/**
+ * @typedef {import('./types').ChromedriverVersionMapping} ChromedriverVersionMapping
+ */
+//# sourceMappingURL=chromedriver.js.map