appium-chromedriver 8.1.0 → 8.2.0

package/build/lib/chromedriver.js

@@ -61,29 +61,55 @@ const WEBVIEW_BUNDLE_IDS = ['com.google.android.webview', 'com.android.webview']
 const VERSION_PATTERN = /([\d.]+)/;
 const CD_VERSION_TIMEOUT = 5000;
 class Chromedriver extends events_1.default.EventEmitter {
-    /**
-     *
-     * @param {import('./types').ChromedriverOpts} args
-     */
+    static EVENT_ERROR = 'chromedriver_error';
+    static EVENT_CHANGED = 'stateChanged';
+    static STATE_STOPPED = 'stopped';
+    static STATE_STARTING = 'starting';
+    static STATE_ONLINE = 'online';
+    static STATE_STOPPING = 'stopping';
+    static STATE_RESTARTING = 'restarting';
+    _log;
+    proxyHost;
+    proxyPort;
+    adb;
+    cmdArgs;
+    proc;
+    useSystemExecutable;
+    chromedriver;
+    executableDir;
+    mappingPath;
+    bundleId;
+    executableVerified;
+    state;
+    _execFunc;
+    jwproxy;
+    isCustomExecutableDir;
+    verbose;
+    logPath;
+    disableBuildCheck;
+    storageClient;
+    details;
+    capabilities;
+    _desiredProtocol;
+    _driverVersion;
+    _onlineStatus;
     constructor(args = {}) {
         super();
         const { host = DEFAULT_HOST, port = DEFAULT_PORT, useSystemExecutable = false, executable, executableDir, bundleId, mappingPath, cmdArgs, adb, verbose, logPath, disableBuildCheck, details, isAutodownloadEnabled = false, reqBasePath, } = args;
         this._log = support_1.logger.getLogger((0, utils_1.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;
         this.state = Chromedriver.STATE_STOPPED;
         // to mock in unit test
         this._execFunc = teen_process_1.exec;
-        /** @type {Record<string, any>} */
         const proxyOpts = {
             server: this.proxyHost,
             port: this.proxyPort,
@@ -93,13 +119,14 @@ class Chromedriver extends events_1.default.EventEmitter {
             proxyOpts.reqBasePath = reqBasePath;
         }
         this.jwproxy = new base_driver_1.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 = (0, utils_1.getChromedriverDir)();
+            this.isCustomExecutableDir = false;
         }
         this.verbose = verbose;
         this.logPath = logPath;
@@ -108,25 +135,236 @@ class Chromedriver extends events_1.default.EventEmitter {
             ? new storage_client_1.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() {
         return this._driverVersion;
     }
+    /**
+     * 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, 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 = this.buildChromedriverArgs();
+        // what are the process stdout/stderr conditions wherein we know that
+        // the process has started to our satisfaction?
+        const startDetector = (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
+            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 = 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);
+        }
+    }
+    /**
+     * Gets the current session ID if the driver is online.
+     * @returns The session ID string, or null if the driver is not online.
+     */
+    sessionId() {
+        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() {
+        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) {
+        if (emitStates) {
+            this.changeState(Chromedriver.STATE_STOPPING);
+        }
+        const runSafeStep = async (f) => {
+            try {
+                return await f();
+            }
+            catch (e) {
+                const err = 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 = (0, utils_1.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, method, body = null) {
+        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, res) {
+        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() {
+        try {
+            await this.jwproxy.command('/url', 'GET');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // Private methods at the tail of the class
+    buildChromedriverArgs() {
+        const args = [`--port=${this.proxyPort}`];
+        if (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');
+        return args;
+    }
     async getDriversMapping() {
         let mapping = lodash_1.default.cloneDeep(utils_1.CHROMEDRIVER_CHROME_MAPPING);
         if (this.mappingPath) {
@@ -140,7 +378,7 @@ class Chromedriver extends events_1.default.EventEmitter {
                     mapping = JSON.parse(await support_1.fs.readFile(this.mappingPath, 'utf8'));
                 }
                 catch (e) {
-                    const err = /** @type {Error} */ (e);
+                    const err = e;
                     this.log.warn(`Error parsing mapping from '${this.mappingPath}': ${err.message}`);
                     this.log.info('Defaulting to the static Chromedriver->Chrome mapping');
                 }
@@ -161,9 +399,6 @@ class Chromedriver extends events_1.default.EventEmitter {
         }
         return mapping;
     }
-    /**
-     * @param {ChromedriverVersionMapping} mapping
-     */
     async getChromedrivers(mapping) {
         // go through the versions available
         const executables = await support_1.fs.glob('*', {
@@ -174,10 +409,7 @@ class Chromedriver extends events_1.default.EventEmitter {
         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 }) => {
+            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) {
@@ -197,7 +429,7 @@ class Chromedriver extends events_1.default.EventEmitter {
                 }));
             }
             catch (e) {
-                const err = /** @type {import('teen_process').ExecError} */ (e);
+                const err = e;
                 if (!(err.message || '').includes('timed out') &&
                     !(err.stdout || '').includes('Starting ChromeDriver')) {
                     return logError(err);
@@ -211,13 +443,13 @@ class Chromedriver extends events_1.default.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
@@ -301,11 +533,6 @@ class Chromedriver extends events_1.default.EventEmitter {
         // make sure it is semver, so later checks won't fail
         return chromeVersion ? semver.coerce(chromeVersion) : null;
     }
-    /**
-     *
-     * @param {ChromedriverVersionMapping} newMapping
-     * @returns {Promise<void>}
-     */
     async updateDriversMapping(newMapping) {
         let shouldUpdateStaticMapping = true;
         if (!this.mappingPath) {
@@ -318,7 +545,7 @@ class Chromedriver extends events_1.default.EventEmitter {
                 shouldUpdateStaticMapping = false;
             }
             catch (e) {
-                const err = /** @type {Error} */ (e);
+                const err = 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}`);
             }
@@ -327,11 +554,6 @@ class Chromedriver extends events_1.default.EventEmitter {
             Object.assign(utils_1.CHROMEDRIVER_CHROME_MAPPING, newMapping);
         }
     }
-    /**
-     * 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() {
         if (!this.adb && !this.isCustomExecutableDir) {
             return await (0, utils_1.getChromedriverBinaryPath)();
@@ -341,10 +563,6 @@ class Chromedriver extends events_1.default.EventEmitter {
             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) {
@@ -363,14 +581,13 @@ class Chromedriver extends events_1.default.EventEmitter {
                 const { version, minBrowserVersion } = retrievedMapping[x];
                 acc[version] = minBrowserVersion;
                 return acc;
-            }, /** @type {ChromedriverVersionMapping} */ ({}));
+            }, {});
             Object.assign(mapping, synchronizedDriversMapping);
             await this.updateDriversMapping(mapping);
             return true;
         };
-        do {
+        while (true) {
             const cds = await this.getChromedrivers(mapping);
-            /** @type {ChromedriverVersionMapping} */
             const missingVersions = {};
             for (const { version, minChromeVersion } of cds) {
                 if (!minChromeVersion || mapping[version]) {
@@ -427,7 +644,7 @@ class Chromedriver extends events_1.default.EventEmitter {
                         }
                     }
                     catch (e) {
-                        const err = /** @type {Error} */ (e);
+                        const err = e;
                         this.log.warn(`Cannot synchronize local chromedrivers with the remote storage: ${err.message}`);
                         this.log.debug(err.stack);
                     }
@@ -443,12 +660,11 @@ class Chromedriver extends events_1.default.EventEmitter {
             this.log.debug(`If a specific version is required, specify it with the 'chromedriverExecutable'` +
                 ` capability.`);
             return binPath;
-            // eslint-disable-next-line no-constant-condition
-        } while (true);
+        }
     }
     async initChromedriverPath() {
         if (this.executableVerified && this.chromedriver) {
-            return /** @type {string} */ (this.chromedriver);
+            return this.chromedriver;
         }
         let chromedriver = this.chromedriver;
         // the executable might be set (if passed in)
@@ -461,18 +677,12 @@ class Chromedriver extends events_1.default.EventEmitter {
         }
         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!`);
+                `${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() {
         if (this.driverVersion) {
             const coercedVersion = semver.coerce(this.driverVersion);
@@ -504,142 +714,6 @@ class Chromedriver extends events_1.default.EventEmitter {
         this._desiredProtocol = base_driver_1.PROTOCOLS.W3C;
         return this._desiredProtocol;
     }
-    /**
-     *
-     * @param {SessionCapabilities} caps
-     * @param {boolean} emitStartingState
-     * @returns {Promise<SessionCapabilities>}
-     */
-    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?.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;
-        /** @type {string|undefined} */
-        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
-            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() {
         // we need to make sure that CD hasn't crashed
         let chromedriverStopped = false;
@@ -649,7 +723,6 @@ class Chromedriver extends events_1.default.EventEmitter {
                 chromedriverStopped = true;
                 return;
             }
-            /** @type {any} */
             const status = await this.getStatus();
             if (!lodash_1.default.isPlainObject(status) || !status.ready) {
                 throw new Error(`The response to the /status API is not valid: ${JSON.stringify(status)}`);
@@ -671,80 +744,24 @@ class Chromedriver extends events_1.default.EventEmitter {
     async getStatus() {
         return await this.jwproxy.command('/status', 'GET');
     }
-    /**
-     * Starts a new session
-     *
-     * @returns {Promise<SessionCapabilities>}
-     */
     async startSession() {
         const sessionCaps = this._desiredProtocol === base_driver_1.PROTOCOLS.W3C
             ? { capabilities: { alwaysMatch: (0, protocol_helpers_1.toW3cCapNames)(this.capabilities) } }
             : { desiredCapabilities: this.capabilities };
         this.log.info(`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));
         this.log.prefix = (0, utils_1.generateLogPrefix)(this, this.jwproxy.sessionId);
         this.changeState(Chromedriver.STATE_ONLINE);
-        return lodash_1.default.has(response, 'capabilities') ? response.capabilities : response;
+        return lodash_1.default.has(response, 'capabilities') && 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 = (0, utils_1.generateLogPrefix)(this);
-        if (emitStates) {
-            this.changeState(Chromedriver.STATE_STOPPED);
-        }
-    }
-    /**
-     *
-     * @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
-     */
-    async proxyReq(req, res) {
-        return await this.jwproxy.proxyReqRes(req, res);
-    }
     async killAll() {
-        let cmd = support_1.system.isWindows()
+        const 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}`);
@@ -765,51 +782,23 @@ class Chromedriver extends events_1.default.EventEmitter {
                 this.log.debug(`Cleaning any old adb forwarded port socket connections`);
             }
             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;
                 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;
-        }
-    }
 }
 exports.Chromedriver = Chromedriver;
-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
- */
 //# sourceMappingURL=chromedriver.js.map