appium-chromedriver 8.0.31 → 8.2.0

package/lib/{chromedriver.js → chromedriver.ts}

@@ -3,7 +3,7 @@ import {JWProxy, PROTOCOLS} from '@appium/base-driver';
 import cp from 'child_process';
 import {system, fs, logger, util} from '@appium/support';
 import {retryInterval, asyncmap} from 'asyncbox';
-import {SubProcess, exec} from 'teen_process';
+import {SubProcess, exec, type ExecError} from 'teen_process';
 import B from 'bluebird';
 import {
   getChromeVersion,
@@ -18,6 +18,10 @@ import path from 'path';
 import {compareVersions} from 'compare-versions';
 import {ChromedriverStorageClient} from './storage-client/storage-client';
 import {toW3cCapNames, getCapValue, toW3cCapName} from './protocol-helpers';
+import type {ADB} from 'appium-adb';
+import type {ProxyOptions, HTTPMethod, HTTPBody} from '@appium/types';
+import type {Request, Response} from 'express';
+import type {ChromedriverOpts, ChromedriverVersionMapping} from './types';
 
 const NEW_CD_VERSION_FORMAT_MAJOR_VERSION = 73;
 const DEFAULT_HOST = '127.0.0.1';
@@ -25,17 +29,60 @@ const MIN_CD_VERSION_WITH_W3C_SUPPORT = 75;
 const DEFAULT_PORT = 9515;
 const CHROME_BUNDLE_ID = 'com.android.chrome';
 const WEBVIEW_SHELL_BUNDLE_ID = 'org.chromium.webview_shell';
-const WEBVIEW_BUNDLE_IDS = ['com.google.android.webview', 'com.android.webview'];
+const WEBVIEW_BUNDLE_IDS = ['com.google.android.webview', 'com.android.webview'] as const;
 const VERSION_PATTERN = /([\d.]+)/;
 
 const CD_VERSION_TIMEOUT = 5000;
 
+interface ChromedriverInfo {
+  executable: string;
+  version: string;
+  minChromeVersion: string | null;
+}
+
+interface NewSessionResponse {
+  capabilities?: Record<string, any>;
+  [key: string]: any;
+}
+
+type SessionCapabilities = Record<string, any>;
+
 export class Chromedriver extends events.EventEmitter {
-  /**
-   *
-   * @param {import('./types').ChromedriverOpts} args
-   */
-  constructor(args = {}) {
+  static readonly EVENT_ERROR = 'chromedriver_error';
+  static readonly EVENT_CHANGED = 'stateChanged';
+  static readonly STATE_STOPPED = 'stopped';
+  static readonly STATE_STARTING = 'starting';
+  static readonly STATE_ONLINE = 'online';
+  static readonly STATE_STOPPING = 'stopping';
+  static readonly STATE_RESTARTING = 'restarting';
+
+  private readonly _log: any;
+  private readonly proxyHost: string;
+  private readonly proxyPort: number;
+  private readonly adb?: ADB;
+  private readonly cmdArgs?: string[];
+  private proc: SubProcess | null;
+  private readonly useSystemExecutable: boolean;
+  private chromedriver?: string;
+  private readonly executableDir: string;
+  private readonly mappingPath?: string;
+  private bundleId?: string;
+  private executableVerified: boolean;
+  state: string;
+  private readonly _execFunc: typeof exec;
+  jwproxy: JWProxy;
+  private readonly isCustomExecutableDir: boolean;
+  private readonly verbose?: boolean;
+  private readonly logPath?: string;
+  private readonly disableBuildCheck: boolean;
+  private readonly storageClient: ChromedriverStorageClient | null;
+  private readonly details?: ChromedriverOpts['details'];
+  private capabilities: SessionCapabilities;
+  private _desiredProtocol: keyof typeof PROTOCOLS | null;
+  private _driverVersion: string | null;
+  private _onlineStatus: Record<string, any> | null;
+
+  constructor(args: ChromedriverOpts = {}) {
     super();
 
     const {
@@ -58,13 +105,12 @@ export class Chromedriver extends events.EventEmitter {
     this._log = logger.getLogger(generateLogPrefix(this));
 
     this.proxyHost = host;
-    this.proxyPort = port;
+    this.proxyPort = parseInt(String(port), 10);
     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;
@@ -73,8 +119,7 @@ export class Chromedriver extends events.EventEmitter {
     // to mock in unit test
     this._execFunc = exec;
 
-    /** @type {Record<string, any>} */
-    const proxyOpts = {
+    const proxyOpts: ProxyOptions = {
       server: this.proxyHost,
       port: this.proxyPort,
       log: this._log,
@@ -83,12 +128,13 @@ export class Chromedriver extends events.EventEmitter {
       proxyOpts.reqBasePath = reqBasePath;
     }
     this.jwproxy = new JWProxy(proxyOpts);
-    if (this.executableDir) {
+    if (executableDir) {
       // Expects the user set the executable directory explicitly
+      this.executableDir = executableDir;
       this.isCustomExecutableDir = true;
     } else {
-      this.isCustomExecutableDir = false;
       this.executableDir = getChromedriverDir();
+      this.isCustomExecutableDir = false;
     }
 
     this.verbose = verbose;
@@ -98,30 +144,260 @@ export class Chromedriver extends events.EventEmitter {
       ? new ChromedriverStorageClient({chromedriverDir: this.executableDir})
       : null;
     this.details = details;
-    /** @type {any} */
     this.capabilities = {};
-    /** @type {keyof PROTOCOLS | null} */
     this._desiredProtocol = null;
 
     // Store the running driver version
-    /** @type {string|null} */
     this._driverVersion = null;
-    /** @type {Record<string, any> | null} */
     this._onlineStatus = null;
   }
 
+  /**
+   * Gets the logger instance for this Chromedriver instance.
+   * @returns The logger instance.
+   */
   get log() {
     return this._log;
   }
 
   /**
-   * @returns {string | null}
+   * Gets the version of the currently running Chromedriver.
+   * @returns The driver version string, or null if not yet determined.
    */
-  get driverVersion() {
+  get driverVersion(): string | null {
     return this._driverVersion;
   }
 
-  async getDriversMapping() {
+  /**
+   * Starts a new Chromedriver session with the given capabilities.
+   * @param caps - The session capabilities to use.
+   * @param emitStartingState - Whether to emit the starting state event (default: true).
+   * @returns A promise that resolves to the session capabilities returned by Chromedriver.
+   * @throws {Error} If Chromedriver fails to start or crashes during startup.
+   */
+  async start(caps: SessionCapabilities, emitStartingState = true): Promise<SessionCapabilities> {
+    this.capabilities = _.cloneDeep(caps);
+
+    // set the logging preferences to ALL the console logs
+    this.capabilities.loggingPrefs = _.cloneDeep(getCapValue(caps, 'loggingPrefs', {}));
+    if (_.isEmpty(this.capabilities.loggingPrefs.browser)) {
+      this.capabilities.loggingPrefs.browser = 'ALL';
+    }
+
+    if (emitStartingState) {
+      this.changeState(Chromedriver.STATE_STARTING);
+    }
+
+    const args = this.buildChromedriverArgs();
+    // what are the process stdout/stderr conditions wherein we know that
+    // the process has started to our satisfaction?
+    const startDetector = (stdout: string) => stdout.startsWith('Starting ');
+
+    let processIsAlive = false;
+    let webviewVersion: string | undefined;
+    try {
+      const chromedriverPath = await this.initChromedriverPath();
+      await this.killAll();
+
+      // set up our subprocess object
+      this.proc = new SubProcess(chromedriverPath, args);
+      processIsAlive = true;
+
+      // handle log output
+      for (const streamName of ['stderr', 'stdout'] as const) {
+        this.proc.on(`line-${streamName}`, (line: string) => {
+          // 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"
+          //   }
+          if (!webviewVersion) {
+            const match = /"Browser": "([^"]+)"/.exec(line);
+            if (match) {
+              webviewVersion = match[1];
+              this.log.debug(`Webview version: '${webviewVersion}'`);
+            }
+          }
+
+          if (this.verbose) {
+            // give the output if it is requested
+            this.log.debug(`[${streamName.toUpperCase()}] ${line}`);
+          }
+        });
+      }
+
+      // handle out-of-bound exit by simply emitting a stopped state
+      this.proc.once('exit', (code: number | null, signal: string | null) => {
+        this._driverVersion = null;
+        this._desiredProtocol = null;
+        this._onlineStatus = null;
+        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.proc?.removeAllListeners();
+        this.proc = null;
+      });
+      this.log.info(`Spawning Chromedriver with: ${this.chromedriver} ${args.join(' ')}`);
+      // start subproc and wait for startDetector
+      await this.proc.start(startDetector);
+      await this.waitForOnline();
+      this.syncProtocol();
+      return await this.startSession();
+    } catch (e) {
+      const err = e as Error;
+      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();
+      }
+      this.proc?.removeAllListeners();
+      this.proc = null;
+
+      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;
+      throw this.log.errorWithException(message);
+    }
+  }
+
+  /**
+   * Gets the current session ID if the driver is online.
+   * @returns The session ID string, or null if the driver is not online.
+   */
+  sessionId(): string | null {
+    return this.state === Chromedriver.STATE_ONLINE ? this.jwproxy.sessionId : null;
+  }
+
+  /**
+   * Restarts the Chromedriver session.
+   * The session will be stopped and then started again with the same capabilities.
+   * @returns A promise that resolves to the session capabilities returned by Chromedriver.
+   * @throws {Error} If the driver is not online or if restart fails.
+   */
+  async restart(): Promise<SessionCapabilities> {
+    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);
+    return await this.start(this.capabilities, false);
+  }
+
+  /**
+   * Stops the Chromedriver session and terminates the process.
+   * @param emitStates - Whether to emit state change events during shutdown (default: true).
+   * @returns A promise that resolves when the session has been stopped.
+   */
+  async stop(emitStates = true): Promise<void> {
+    if (emitStates) {
+      this.changeState(Chromedriver.STATE_STOPPING);
+    }
+    const runSafeStep = async (f: () => Promise<any> | any): Promise<void> => {
+      try {
+        return await f();
+      } catch (e) {
+        const err = e as Error;
+        this.log.warn(err.message);
+        this.log.debug(err.stack);
+      }
+    };
+    await runSafeStep(() => this.jwproxy.command('', 'DELETE'));
+    await runSafeStep(() => {
+      this.proc?.stop('SIGTERM', 20000);
+      this.proc?.removeAllListeners();
+      this.proc = null;
+    });
+    this.log.prefix = generateLogPrefix(this);
+    if (emitStates) {
+      this.changeState(Chromedriver.STATE_STOPPED);
+    }
+  }
+
+  /**
+   * Sends a command to the Chromedriver server.
+   * @param url - The endpoint URL (e.g., '/url', '/session').
+   * @param method - The HTTP method to use ('POST', 'GET', or 'DELETE').
+   * @param body - Optional request body for POST requests.
+   * @returns A promise that resolves to the response from Chromedriver.
+   */
+  async sendCommand(url: string, method: HTTPMethod, body: HTTPBody = null): Promise<HTTPBody> {
+    return await this.jwproxy.command(url, method, body);
+  }
+
+  /**
+   * Proxies an HTTP request/response to the Chromedriver server.
+   * @param req - The incoming HTTP request object.
+   * @param res - The outgoing HTTP response object.
+   * @returns A promise that resolves when the proxying is complete.
+   */
+  async proxyReq(req: Request, res: Response): Promise<void> {
+    await this.jwproxy.proxyReqRes(req, res);
+  }
+
+  /**
+   * Checks if Chromedriver is currently able to automate webviews.
+   * Sometimes Chromedriver stops automating webviews; this method runs a simple
+   * command to determine the current state.
+   * @returns A promise that resolves to true if webviews are working, false otherwise.
+   */
+  async hasWorkingWebview(): Promise<boolean> {
+    try {
+      await this.jwproxy.command('/url', 'GET');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // Private methods at the tail of the class
+
+  private buildChromedriverArgs(): string[] {
+    const args = [`--port=${this.proxyPort}`];
+    if (this.adb?.adbPort) {
+      args.push(`--adb-port=${this.adb.adbPort}`);
+    }
+    if (_.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');
+    return args;
+  }
+
+  private async getDriversMapping(): Promise<ChromedriverVersionMapping> {
     let mapping = _.cloneDeep(CHROMEDRIVER_CHROME_MAPPING);
     if (this.mappingPath) {
       this.log.debug(`Attempting to use Chromedriver->Chrome mapping from '${this.mappingPath}'`);
@@ -132,7 +408,7 @@ export class Chromedriver extends events.EventEmitter {
         try {
           mapping = JSON.parse(await fs.readFile(this.mappingPath, 'utf8'));
         } catch (e) {
-          const err = /** @type {Error} */ (e);
+          const err = e as Error;
           this.log.warn(`Error parsing mapping from '${this.mappingPath}': ${err.message}`);
           this.log.info('Defaulting to the static Chromedriver->Chrome mapping');
         }
@@ -153,10 +429,7 @@ export class Chromedriver extends events.EventEmitter {
     return mapping;
   }
 
-  /**
-   * @param {ChromedriverVersionMapping} mapping
-   */
-  async getChromedrivers(mapping) {
+  private async getChromedrivers(mapping: ChromedriverVersionMapping): Promise<ChromedriverInfo[]> {
     // go through the versions available
     const executables = await fs.glob('*', {
       cwd: this.executableDir,
@@ -168,11 +441,16 @@ export class Chromedriver extends events.EventEmitter {
         `in '${this.executableDir}'`,
     );
     const cds = (
-      await asyncmap(executables, async (executable) => {
-        /**
-         * @param {{message: string, stdout?: string, stderr?: string}} opts
-         */
-        const logError = ({message, stdout, stderr}) => {
+      await asyncmap(executables, async (executable: string) => {
+        const logError = ({
+          message,
+          stdout,
+          stderr,
+        }: {
+          message: string;
+          stdout?: string;
+          stderr?: string;
+        }): null => {
           let errMsg =
             `Cannot retrieve version number from '${path.basename(
               executable,
@@ -188,14 +466,14 @@ export class Chromedriver extends events.EventEmitter {
           return null;
         };
 
-        let stdout;
-        let stderr;
+        let stdout: string;
+        let stderr: string | undefined;
         try {
           ({stdout, stderr} = await this._execFunc(executable, ['--version'], {
             timeout: CD_VERSION_TIMEOUT,
           }));
         } catch (e) {
-          const err = /** @type {import('teen_process').ExecError} */ (e);
+          const err = e as ExecError;
           if (
             !(err.message || '').includes('timed out') &&
             !(err.stdout || '').includes('Starting ChromeDriver')
@@ -213,15 +491,13 @@ export class Chromedriver extends events.EventEmitter {
           return logError({message: 'Cannot parse the version string', stdout, stderr});
         }
         let version = match[1];
-        let minChromeVersion = mapping[version];
+        let minChromeVersion = mapping[version] || null;
         const coercedVersion = semver.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];
+            version = `${coercedVersion.major}.${coercedVersion.minor}`;
+            minChromeVersion = mapping[version] || null;
           }
           if (!minChromeVersion && coercedVersion.major >= NEW_CD_VERSION_FORMAT_MAJOR_VERSION) {
             // Assume the major Chrome version is the same as the corresponding driver major version
@@ -235,7 +511,7 @@ export class Chromedriver extends events.EventEmitter {
         };
       })
     )
-      .filter((cd) => !!cd)
+      .filter((cd): cd is ChromedriverInfo => !!cd)
       .sort((a, b) => compareVersions(b.version, a.version));
     if (_.isEmpty(cds)) {
       this.log.info(`No Chromedrivers were found in '${this.executableDir}'`);
@@ -252,7 +528,7 @@ export class Chromedriver extends events.EventEmitter {
     return cds;
   }
 
-  async getChromeVersion() {
+  private async getChromeVersion(): Promise<semver.SemVer | null> {
     // 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``
@@ -267,7 +543,7 @@ export class Chromedriver extends events.EventEmitter {
       }
     }
 
-    let chromeVersion;
+    let chromeVersion: string | undefined;
 
     // in case of WebView Browser Tester, simply try to find the underlying webview
     if (this.bundleId === WEBVIEW_SHELL_BUNDLE_ID) {
@@ -321,12 +597,7 @@ export class Chromedriver extends events.EventEmitter {
     return chromeVersion ? semver.coerce(chromeVersion) : null;
   }
 
-  /**
-   *
-   * @param {ChromedriverVersionMapping} newMapping
-   * @returns {Promise<void>}
-   */
-  async updateDriversMapping(newMapping) {
+  private async updateDriversMapping(newMapping: ChromedriverVersionMapping): Promise<void> {
     let shouldUpdateStaticMapping = true;
     if (!this.mappingPath) {
       this.log.warn('No mapping path provided');
@@ -337,7 +608,7 @@ export class Chromedriver extends events.EventEmitter {
         await fs.writeFile(this.mappingPath, JSON.stringify(newMapping, null, 2), 'utf8');
         shouldUpdateStaticMapping = false;
       } catch (e) {
-        const err = /** @type {Error} */ (e);
+        const err = e as Error;
         this.log.warn(
           `Cannot store the updated chromedrivers mapping into '${this.mappingPath}'. ` +
             `This may reduce the performance of further executions. Original error: ${err.message}`,
@@ -349,12 +620,7 @@ export class Chromedriver extends events.EventEmitter {
     }
   }
 
-  /**
-   * When executableDir is given explicitly for non-adb environment,
-   * this method will respect the executableDir rather than the system installed binary.
-   * @returns {Promise<string>}
-   */
-  async getCompatibleChromedriver() {
+  private async getCompatibleChromedriver(): Promise<string> {
     if (!this.adb && !this.isCustomExecutableDir) {
       return await getChromedriverBinaryPath();
     }
@@ -365,11 +631,7 @@ export class Chromedriver extends events.EventEmitter {
     }
 
     let didStorageSync = false;
-    /**
-     *
-     * @param {import('semver').SemVer} chromeVersion
-     */
-    const syncChromedrivers = async (chromeVersion) => {
+    const syncChromedrivers = async (chromeVersion: semver.SemVer): Promise<boolean> => {
       didStorageSync = true;
       if (!this.storageClient) {
         return false;
@@ -389,17 +651,16 @@ export class Chromedriver extends events.EventEmitter {
         const {version, minBrowserVersion} = retrievedMapping[x];
         acc[version] = minBrowserVersion;
         return acc;
-      }, /** @type {ChromedriverVersionMapping} */ ({}));
+      }, {} as ChromedriverVersionMapping);
       Object.assign(mapping, synchronizedDriversMapping);
       await this.updateDriversMapping(mapping);
       return true;
     };
 
-    do {
+    while (true) {
       const cds = await this.getChromedrivers(mapping);
 
-      /** @type {ChromedriverVersionMapping} */
-      const missingVersions = {};
+      const missingVersions: ChromedriverVersionMapping = {};
       for (const {version, minChromeVersion} of cds) {
         if (!minChromeVersion || mapping[version]) {
           continue;
@@ -473,7 +734,7 @@ export class Chromedriver extends events.EventEmitter {
               continue;
             }
           } catch (e) {
-            const err = /** @type {Error} */ (e);
+            const err = e as Error;
             this.log.warn(
               `Cannot synchronize local chromedrivers with the remote storage: ${err.message}`,
             );
@@ -499,13 +760,12 @@ export class Chromedriver extends events.EventEmitter {
           ` capability.`,
       );
       return binPath;
-      // eslint-disable-next-line no-constant-condition
-    } while (true);
+    }
   }
 
-  async initChromedriverPath() {
+  private async initChromedriverPath(): Promise<string> {
     if (this.executableVerified && this.chromedriver) {
-      return /** @type {string} */ (this.chromedriver);
+      return this.chromedriver;
     }
 
     let chromedriver = this.chromedriver;
@@ -521,21 +781,15 @@ export class Chromedriver extends events.EventEmitter {
     if (!(await fs.exists(chromedriver))) {
       throw new Error(
         `Trying to use a chromedriver binary at the path ` +
-          `${this.chromedriver}, but it doesn't exist!`,
+          `${chromedriver}, but it doesn't exist!`,
       );
     }
     this.executableVerified = true;
-    this.log.info(`Set chromedriver binary as: ${this.chromedriver}`);
-    return /** @type {string} */ (this.chromedriver);
+    this.log.info(`Set chromedriver binary as: ${chromedriver}`);
+    return chromedriver;
   }
 
-  /**
-   * Determines the driver communication protocol
-   * based on various validation rules.
-   *
-   * @returns {keyof PROTOCOLS}
-   */
-  syncProtocol() {
+  private syncProtocol(): keyof typeof PROTOCOLS {
     if (this.driverVersion) {
       const coercedVersion = semver.coerce(this.driverVersion);
       if (!coercedVersion || coercedVersion.major < MIN_CD_VERSION_WITH_W3C_SUPPORT) {
@@ -571,158 +825,7 @@ export class Chromedriver extends events.EventEmitter {
     return this._desiredProtocol;
   }
 
-  /**
-   *
-   * @param {SessionCapabilities} caps
-   * @param {boolean} emitStartingState
-   * @returns {Promise<SessionCapabilities>}
-   */
-  async start(caps, emitStartingState = true) {
-    this.capabilities = _.cloneDeep(caps);
-
-    // set the logging preferences to ALL the console logs
-    this.capabilities.loggingPrefs = _.cloneDeep(getCapValue(caps, 'loggingPrefs', {}));
-    if (_.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?.adbPort) {
-      args.push(`--adb-port=${this.adb.adbPort}`);
-    }
-    if (_.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;
-    /** @type {string|undefined} */
-    let webviewVersion;
-    try {
-      const chromedriverPath = await this.initChromedriverPath();
-      await this.killAll();
-
-      // set up our subprocess object
-      this.proc = new SubProcess(chromedriverPath, args);
-      processIsAlive = true;
-
-      // handle log output
-      for (const streamName of ['stderr', 'stdout']) {
-        this.proc.on(`line-${streamName}`, (line) => {
-          // 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"
-          //   }
-          if (!webviewVersion) {
-            const match = /"Browser": "([^"]+)"/.exec(line);
-            if (match) {
-              webviewVersion = match[1];
-              this.log.debug(`Webview version: '${webviewVersion}'`);
-            }
-          }
-
-          if (this.verbose) {
-            // give the output if it is requested
-            this.log.debug(`[${streamName.toUpperCase()}] ${line}`);
-          }
-        });
-      }
-
-      // handle out-of-bound exit by simply emitting a stopped state
-      this.proc.once('exit', (code, signal) => {
-        this._driverVersion = null;
-        this._desiredProtocol = null;
-        this._onlineStatus = null;
-        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.proc?.removeAllListeners();
-        this.proc = null;
-      });
-      this.log.info(`Spawning Chromedriver with: ${this.chromedriver} ${args.join(' ')}`);
-      // start subproc and wait for startDetector
-      await this.proc.start(startDetector);
-      await this.waitForOnline();
-      this.syncProtocol();
-      return 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();
-      }
-      this.proc?.removeAllListeners();
-      this.proc = null;
-
-      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;
-      throw this.log.errorWithException(message);
-    }
-  }
-
-  sessionId() {
-    return this.state === Chromedriver.STATE_ONLINE ? this.jwproxy.sessionId : null;
-  }
-
-  /**
-   * Restarts the chromedriver session
-   *
-   * @returns {Promise<SessionCapabilities>}
-   */
-  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);
-    return await this.start(this.capabilities, false);
-  }
-
-  async waitForOnline() {
+  private async waitForOnline(): Promise<void> {
     // we need to make sure that CD hasn't crashed
     let chromedriverStopped = false;
     await retryInterval(20, 200, async () => {
@@ -731,8 +834,7 @@ export class Chromedriver extends events.EventEmitter {
         chromedriverStopped = true;
         return;
       }
-      /** @type {any} */
-      const status = await this.getStatus();
+      const status: any = await this.getStatus();
       if (!_.isPlainObject(status) || !status.ready) {
         throw new Error(`The response to the /status API is not valid: ${JSON.stringify(status)}`);
       }
@@ -750,16 +852,11 @@ export class Chromedriver extends events.EventEmitter {
     }
   }
 
-  async getStatus() {
+  private async getStatus(): Promise<any> {
     return await this.jwproxy.command('/status', 'GET');
   }
 
-  /**
-   * Starts a new session
-   *
-   * @returns {Promise<SessionCapabilities>}
-   */
-  async startSession() {
+  private async startSession(): Promise<SessionCapabilities> {
     const sessionCaps =
       this._desiredProtocol === PROTOCOLS.W3C
         ? {capabilities: {alwaysMatch: toW3cCapNames(this.capabilities)}}
@@ -768,75 +865,20 @@ export class Chromedriver extends events.EventEmitter {
       `Starting ${this._desiredProtocol} Chromedriver session with capabilities: ` +
         JSON.stringify(sessionCaps, null, 2),
     );
-    const response = /** @type {NewSessionResponse} */ (
-      await this.jwproxy.command('/session', 'POST', sessionCaps)
-    );
+    const response = (await this.jwproxy.command('/session', 'POST', sessionCaps)) as NewSessionResponse;
     this.log.prefix = generateLogPrefix(this, this.jwproxy.sessionId);
     this.changeState(Chromedriver.STATE_ONLINE);
-    return _.has(response, 'capabilities') ? response.capabilities : response;
-  }
-
-  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.proc?.removeAllListeners();
-      this.proc = null;
-    });
-    this.log.prefix = generateLogPrefix(this);
-    if (emitStates) {
-      this.changeState(Chromedriver.STATE_STOPPED);
-    }
+    return _.has(response, 'capabilities') && response.capabilities ? response.capabilities : (response as SessionCapabilities);
   }
 
-  /**
-   *
-   * @param {string} state
-   */
-  changeState(state) {
+  private changeState(state: string): void {
     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
-   */
-  async proxyReq(req, res) {
-    return await this.jwproxy.proxyReqRes(req, res);
-  }
-
-  async killAll() {
-    let cmd = system.isWindows()
+  private async killAll(): Promise<void> {
+    const cmd = 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}`);
@@ -858,52 +900,21 @@ export class Chromedriver extends events.EventEmitter {
       }
 
       try {
-        for (let conn of await this.adb.getForwardList()) {
+        for (const 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+/);
+          const params = conn.split(/\s+/);
           if (params.length > 1) {
             await this.adb.removePortForward(params[1].replace(/[\D]*/, ''));
           }
         }
       } catch (e) {
-        const err = /** @type {Error} */ (e);
+        const err = e as Error;
         this.log.warn(`Unable to clean forwarded ports. Error: '${err.message}'. Continuing.`);
       }
     }
   }
-
-  /**
-   * @returns {Promise<boolean>}
-   */
-  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 {
-      return false;
-    }
-  }
 }
-
-Chromedriver.EVENT_ERROR = 'chromedriver_error';
-Chromedriver.EVENT_CHANGED = 'stateChanged';
-Chromedriver.STATE_STOPPED = 'stopped';
-Chromedriver.STATE_STARTING = 'starting';
-Chromedriver.STATE_ONLINE = 'online';
-Chromedriver.STATE_STOPPING = 'stopping';
-Chromedriver.STATE_RESTARTING = 'restarting';
-
-/**
- * @typedef {import('./types').ChromedriverVersionMapping} ChromedriverVersionMapping
- */
-
-/**
- * @typedef {{capabilities: Record<string, any>}} NewSessionResponse
- * @typedef {Record<string, any>} SessionCapabilities
- */