@wdio/utils 8.13.13 → 8.15.0

package/build/constants.d.ts

@@ -79,4 +79,13 @@ export declare const UNICODE_CHARACTERS: {
     readonly ZenkakuHankaku: "";
     readonly Zenkaku_Hankaku: "";
 };
+export declare const SUPPORTED_BROWSERNAMES: {
+    chrome: string[];
+    firefox: string[];
+    edge: string[];
+    safari: string[];
+};
+export declare const DEFAULT_HOSTNAME = "0.0.0.0";
+export declare const DEFAULT_PROTOCOL = "http";
+export declare const DEFAULT_PATH = "/";
 //# sourceMappingURL=constants.d.ts.map

package/build/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4ErB,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4ErB,CAAA;AAEV,eAAO,MAAM,sBAAsB;;;;;CAKlC,CAAA;AAED,eAAO,MAAM,gBAAgB,YAAY,CAAA;AACzC,eAAO,MAAM,gBAAgB,SAAS,CAAA;AACtC,eAAO,MAAM,YAAY,MAAM,CAAA"}

package/build/constants.js

@@ -79,3 +79,12 @@ export const UNICODE_CHARACTERS = {
     'ZenkakuHankaku': '\uE040',
     'Zenkaku_Hankaku': '\uE040'
 };
+export const SUPPORTED_BROWSERNAMES = {
+    chrome: ['chrome', 'googlechrome', 'chromium', 'chromium-browser'],
+    firefox: ['firefox', 'ff', 'mozilla', 'mozilla firefox'],
+    edge: ['edge', 'microsoftedge', 'msedge'],
+    safari: ['safari', 'safari technology preview']
+};
+export const DEFAULT_HOSTNAME = '0.0.0.0';
+export const DEFAULT_PROTOCOL = 'http';
+export const DEFAULT_PATH = '/';

package/build/driver/index.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import cp from 'node:child_process';
+import { type SafaridriverOptions as SafaridriverParameters } from 'safaridriver';
+import { type GeckodriverParameters } from 'geckodriver';
+import { type EdgedriverParameters } from 'edgedriver';
+import type { InstallOptions } from '@puppeteer/browsers';
+import type { Options } from '@wdio/types';
+export type ChromedriverParameters = InstallOptions & Omit<EdgedriverParameters, 'port' | 'edgeDriverVersion' | 'customEdgeDriverPath'>;
+declare global {
+    namespace WebdriverIO {
+        interface ChromedriverOptions extends ChromedriverParameters {
+        }
+        interface GeckodriverOptions extends Omit<GeckodriverParameters, 'port'> {
+        }
+        interface EdgedriverOptions extends Omit<EdgedriverParameters, 'port'> {
+        }
+        interface SafaridriverOptions extends Omit<SafaridriverParameters, 'port'> {
+        }
+    }
+}
+export declare function startWebDriver(options: Options.WebDriver): Promise<cp.ChildProcess | undefined>;
+//# sourceMappingURL=index.d.ts.map

package/build/driver/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/driver/index.ts"],"names":[],"mappings":";AAEA,OAAO,EAAyB,MAAM,oBAAoB,CAAA;AAO1D,OAAO,EAA8B,KAAK,mBAAmB,IAAI,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAC7G,OAAO,EAA6B,KAAK,qBAAqB,EAAE,MAAM,aAAa,CAAA;AACnF,OAAO,EAA4B,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEzD,OAAO,KAAK,EAAgB,OAAO,EAAE,MAAM,aAAa,CAAA;AAQxD,MAAM,MAAM,sBAAsB,GAAG,cAAc,GAAG,IAAI,CAAC,oBAAoB,EAAE,MAAM,GAAG,mBAAmB,GAAG,sBAAsB,CAAC,CAAA;AACvI,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,WAAW,CAAC;QAClB,UAAU,mBAAoB,SAAQ,sBAAsB;SAAG;QAC/D,UAAU,kBAAmB,SAAQ,IAAI,CAAC,qBAAqB,EAAE,MAAM,CAAC;SAAG;QAC3E,UAAU,iBAAkB,SAAQ,IAAI,CAAC,oBAAoB,EAAE,MAAM,CAAC;SAAG;QACzE,UAAU,mBAAoB,SAAQ,IAAI,CAAC,sBAAsB,EAAE,MAAM,CAAC;SAAG;KAChF;CACJ;AAID,wBAAsB,cAAc,CAAE,OAAO,EAAE,OAAO,CAAC,SAAS,wCAoH/D"}

package/build/driver/index.js

@@ -0,0 +1,117 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import cp from 'node:child_process';
+import getPort from 'get-port';
+import waitPort from 'wait-port';
+import logger from '@wdio/logger';
+import { deepmerge } from 'deepmerge-ts';
+import { start as startSafaridriver } from 'safaridriver';
+import { start as startGeckodriver } from 'geckodriver';
+import { start as startEdgedriver } from 'edgedriver';
+import { parseParams, setupChrome, definesRemoteDriver, setupChromedriver, isChrome, isFirefox, isEdge, isSafari, getCacheDir } from './utils.js';
+import { SUPPORTED_BROWSERNAMES } from '../constants.js';
+const log = logger('@wdio/utils');
+export async function startWebDriver(options) {
+    /**
+     * in case we are running unit tests, just return
+     */
+    if (process.env.WDIO_SKIP_DRIVER_SETUP) {
+        options.hostname = '0.0.0.0';
+        options.port = 4321;
+        return;
+    }
+    /**
+     * if any of the connection parameter are set, don't start any driver
+     */
+    if (definesRemoteDriver(options)) {
+        log.info(`Connecting to existing driver at ${options.protocol}://${options.hostname}:${options.port}${options.path}`);
+        return;
+    }
+    let driverProcess;
+    let driver = '';
+    const start = Date.now();
+    const caps = options.capabilities.alwaysMatch || options.capabilities;
+    /**
+     * session might be a mobile session so don't do anything
+     */
+    if (!caps.browserName) {
+        throw new Error('No "browserName" defined in capabilities nor hostname or port found!\n' +
+            'If you like to run a mobile session with Appium, make sure to set "hostname" and "port" in your ' +
+            'WebdriverIO options. If you like to run a local browser session make sure to pick from one of ' +
+            `the following browser names: ${Object.values(SUPPORTED_BROWSERNAMES).flat(Infinity)}`);
+    }
+    const port = await getPort();
+    const cacheDir = getCacheDir(options, caps);
+    if (isChrome(caps.browserName)) {
+        /**
+         * Chrome
+         */
+        const chromedriverOptions = caps['wdio:chromedriverOptions'] || {};
+        const { executablePath: chromeExecuteablePath, browserVersion } = await setupChrome(cacheDir, caps);
+        const { executablePath: chromedriverExcecuteablePath } = await setupChromedriver(cacheDir, browserVersion);
+        caps['goog:chromeOptions'] = deepmerge({ binary: chromeExecuteablePath }, caps['goog:chromeOptions'] || {});
+        chromedriverOptions.allowedOrigins = chromedriverOptions.allowedOrigins || ['*'];
+        chromedriverOptions.allowedIps = chromedriverOptions.allowedIps || [''];
+        const driverParams = parseParams({ port, ...chromedriverOptions });
+        driverProcess = cp.spawn(chromedriverExcecuteablePath, driverParams);
+        driver = `Chromedriver v${browserVersion} with params ${driverParams.join(' ')}`;
+    }
+    else if (isSafari(caps.browserName)) {
+        const safaridriverOptions = caps['wdio:safaridriverOptions'] || {};
+        /**
+         * Safari
+         */
+        driver = 'SafariDriver';
+        driverProcess = startSafaridriver({
+            useTechnologyPreview: Boolean(caps.browserName.match(/preview/i)),
+            ...safaridriverOptions,
+            port
+        });
+        /**
+         * set "Host" header as it is required by Safaridriver
+         */
+        options.headers = deepmerge({ Host: 'localhost' }, (options.headers || {}));
+    }
+    else if (isFirefox(caps.browserName)) {
+        /**
+         * Firefox
+         */
+        const geckodriverOptions = caps['wdio:geckodriverOptions'] || {};
+        driver = 'GeckoDriver';
+        driverProcess = await startGeckodriver({ ...geckodriverOptions, cacheDir, port });
+    }
+    else if (isEdge(caps.browserName)) {
+        /**
+         * Microsoft Edge
+         */
+        const edgedriverOptions = caps['wdio:edgedriverOptions'] || {};
+        driver = 'EdgeDriver';
+        driverProcess = await startEdgedriver({ ...edgedriverOptions, cacheDir, port }).catch((err) => {
+            log.warn(`Couldn't start EdgeDriver: ${err.message}, retry ...`);
+            return startEdgedriver({ ...edgedriverOptions, cacheDir, port });
+        });
+        /**
+         * Microsoft Edge is very particular when it comes to browser names
+         */
+        caps.browserName = 'MicrosoftEdge';
+    }
+    else {
+        throw new Error(`Unknown browser name "${caps.browserName}". Make sure to pick from one of the following ` +
+            Object.values(SUPPORTED_BROWSERNAMES).flat(Infinity));
+    }
+    if (options.outputDir) {
+        const logIdentifier = driver.split(' ').shift()?.toLowerCase();
+        const logFileName = process.env.WDIO_WORKER_ID
+            ? `wdio-${process.env.WDIO_WORKER_ID}-${logIdentifier}.log`
+            : `wdio-${logIdentifier}-${port}.log`;
+        const logFile = path.resolve(options.outputDir, logFileName);
+        const logStream = fs.createWriteStream(logFile, { flags: 'w' });
+        driverProcess.stdout?.pipe(logStream);
+        driverProcess.stderr?.pipe(logStream);
+    }
+    await waitPort({ port, output: 'silent' });
+    options.hostname = '0.0.0.0';
+    options.port = port;
+    log.info(`Started ${driver} in ${Date.now() - start}ms on port ${port}`);
+    return driverProcess;
+}

package/build/driver/manager.d.ts

@@ -0,0 +1,4 @@
+import type { Options, Capabilities } from '@wdio/types';
+export declare function setupDriver(options: Omit<Options.WebDriver, 'capabilities'>, caps: Capabilities.RemoteCapabilities): Promise<unknown[] | undefined>;
+export declare function setupBrowser(options: Omit<Options.WebDriver, 'capabilities'>, caps: Capabilities.RemoteCapabilities): Promise<unknown[]> | undefined;
+//# sourceMappingURL=manager.d.ts.map

package/build/driver/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/driver/manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAyFxD,wBAAsB,WAAW,CAAE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,cAAc,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,kBAAkB,kCAazH;AAED,wBAAgB,YAAY,CAAE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,cAAc,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,kBAAkB,kCAepH"}

package/build/driver/manager.js

@@ -0,0 +1,98 @@
+import logger from '@wdio/logger';
+import { getCacheDir, definesRemoteDriver, isSafari, isEdge, isFirefox, isChrome, setupChromedriver, setupEdgedriver, setupGeckodriver, setupChrome } from './utils.js';
+const log = logger('@wdio/utils');
+const UNDEFINED_BROWSER_VERSION = null;
+function mapCapabilities(options, caps, task, taskItemLabel) {
+    const capabilitiesToRequireSetup = (Array.isArray(caps)
+        ? caps.map((cap) => {
+            const w3cCaps = cap;
+            const multiremoteCaps = cap;
+            const isMultiremote = Boolean(multiremoteCaps[Object.keys(cap)[0]].capabilities);
+            if (isMultiremote) {
+                return Object.values(multiremoteCaps).map((c) => c.capabilities);
+            }
+            else if (w3cCaps.alwaysMatch) {
+                return w3cCaps.alwaysMatch;
+            }
+            return cap;
+        }).flat()
+        : Object.values(caps).map((mrOpts) => {
+            const w3cCaps = mrOpts.capabilities;
+            if (w3cCaps.alwaysMatch) {
+                return w3cCaps.alwaysMatch;
+            }
+            return mrOpts.capabilities;
+        })).flat().filter((cap) => (
+    /**
+     * only set up driver if
+     *   - browserName is defined so we know it is a browser session
+     *   - we are not about to run a cloud session
+     *   - we are not running Safari (driver already installed on macOS)
+     */
+    cap.browserName &&
+        !definesRemoteDriver(options) &&
+        !isSafari(cap.browserName)));
+    /**
+     * nothing to setup
+     */
+    if (capabilitiesToRequireSetup.length === 0) {
+        return;
+    }
+    /**
+     * get all browser names and versions that need driver setup
+     */
+    const queueByBrowserName = capabilitiesToRequireSetup.reduce((queue, cap) => {
+        if (!cap.browserName) {
+            return queue;
+        }
+        if (!queue.has(cap.browserName)) {
+            queue.set(cap.browserName, new Map());
+        }
+        const browserVersion = cap.browserVersion || UNDEFINED_BROWSER_VERSION;
+        queue.get(cap.browserName).set(browserVersion, cap);
+        return queue;
+    }, new Map());
+    const driverToSetupString = Array.from(queueByBrowserName.entries())
+        .map(([browserName, versions]) => `${browserName}@${Array.from(versions.keys()).map((bv) => bv || 'stable').join(', ')}`)
+        .join(' - ');
+    log.info(`Setting up ${taskItemLabel} for: ${driverToSetupString}`);
+    return Promise.all(Array.from(queueByBrowserName.entries()).map(([browserName, queueByBrowserVersion]) => {
+        return Array.from(queueByBrowserVersion).map(([browserVersion, cap]) => task({
+            ...cap,
+            browserName,
+            ...(browserVersion !== UNDEFINED_BROWSER_VERSION ? { browserVersion } : {})
+        }));
+    }).flat());
+}
+export async function setupDriver(options, caps) {
+    return mapCapabilities(options, caps, async (cap) => {
+        const cacheDir = getCacheDir(options, cap);
+        if (isEdge(cap.browserName)) {
+            return setupEdgedriver(cacheDir, cap.browserVersion);
+        }
+        else if (isFirefox(cap.browserName)) {
+            return setupGeckodriver(cacheDir, cap.browserVersion);
+        }
+        else if (isChrome(cap.browserName)) {
+            return setupChromedriver(cacheDir, cap.browserVersion);
+        }
+        return Promise.resolve();
+    }, 'browser driver');
+}
+export function setupBrowser(options, caps) {
+    return mapCapabilities(options, caps, async (cap) => {
+        const cacheDir = getCacheDir(options, cap);
+        if (isEdge(cap.browserName)) {
+            // not yet implemented
+            return Promise.resolve();
+        }
+        else if (isFirefox(cap.browserName)) {
+            // not yet implemented
+            return Promise.resolve();
+        }
+        else if (isChrome(cap.browserName)) {
+            return setupChrome(cacheDir, cap);
+        }
+        return Promise.resolve();
+    }, 'browser binaries');
+}

package/build/driver/utils.d.ts

@@ -0,0 +1,36 @@
+import type { EdgedriverParameters } from 'edgedriver';
+import type { Options, Capabilities } from '@wdio/types';
+export declare function parseParams(params: EdgedriverParameters): string[];
+export declare function getLocalChromePath(): string | undefined;
+export declare function getBuildIdByPath(chromePath?: string): string | undefined;
+export declare const downloadProgressCallback: (artifact: string, downloadedBytes: number, totalBytes: number) => void;
+export declare function setupChrome(cacheDir: string, caps: Capabilities.Capabilities): Promise<{
+    cacheDir: string;
+    platform: import("@puppeteer/browsers").BrowserPlatform;
+    executablePath: string;
+    buildId: string;
+    browserVersion?: undefined;
+} | {
+    executablePath: string;
+    browserVersion: string;
+    cacheDir?: undefined;
+    platform?: undefined;
+    buildId?: undefined;
+}>;
+export declare function getCacheDir(options: Pick<Options.WebDriver, 'cacheDir'>, caps: Capabilities.Capabilities): string;
+export declare function setupChromedriver(cacheDir: string, driverVersion?: string): Promise<{
+    executablePath: string;
+}>;
+export declare function setupGeckodriver(cacheDir: string, driverVersion?: string): Promise<string>;
+export declare function setupEdgedriver(cacheDir: string, driverVersion?: string): Promise<string>;
+/**
+ * helper method to determine if we need to start a browser driver
+ * which is: whenever the user has set connection options that differ from
+ * the default, or a port is set
+ */
+export declare function definesRemoteDriver(options: Pick<Options.WebDriver, 'protocol' | 'hostname' | 'port' | 'path'>): boolean;
+export declare function isChrome(browserName?: string): boolean;
+export declare function isSafari(browserName?: string): boolean;
+export declare function isFirefox(browserName?: string): boolean;
+export declare function isEdge(browserName?: string): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/build/driver/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/driver/utils.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAOxD,wBAAgB,WAAW,CAAC,MAAM,EAAE,oBAAoB,YAYvD;AAED,wBAAgB,kBAAkB,uBAOjC;AAED,wBAAgB,gBAAgB,CAAC,UAAU,CAAC,EAAE,MAAM,sBAenD;AAGD,eAAO,MAAM,wBAAwB,aAAc,MAAM,mBAAmB,MAAM,cAAc,MAAM,SAOrG,CAAA;AAED,wBAAsB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,CAAC,YAAY;;;;;;;;;;;;GAmDlF;AAED,wBAAgB,WAAW,CAAE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,UAAU,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,YAAY,UASzG;AAED,wBAAsB,iBAAiB,CAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM;;GA8DhF;AAED,wBAAgB,gBAAgB,CAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,mBAEzE;AAED,wBAAgB,eAAe,CAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,mBAExE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC,WAO9G;AAED,wBAAgB,QAAQ,CAAE,WAAW,CAAC,EAAE,MAAM,WAE7C;AACD,wBAAgB,QAAQ,CAAE,WAAW,CAAC,EAAE,MAAM,WAE7C;AACD,wBAAgB,SAAS,CAAE,WAAW,CAAC,EAAE,MAAM,WAE9C;AACD,wBAAgB,MAAM,CAAE,WAAW,CAAC,EAAE,MAAM,WAE3C"}

package/build/driver/utils.js

@@ -0,0 +1,207 @@
+import os from 'node:os';
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import cp from 'node:child_process';
+import got from 'got';
+import decamelize from 'decamelize';
+import logger from '@wdio/logger';
+import { getChromePath } from 'chrome-launcher';
+import { install, canDownload, resolveBuildId, detectBrowserPlatform, Browser, ChromeReleaseChannel, computeExecutablePath } from '@puppeteer/browsers';
+import { download as downloadGeckodriver } from 'geckodriver';
+import { download as downloadEdgedriver } from 'edgedriver';
+import { DEFAULT_HOSTNAME, DEFAULT_PROTOCOL, DEFAULT_PATH, SUPPORTED_BROWSERNAMES } from '../constants.js';
+const log = logger('webdriver');
+const EXCLUDED_PARAMS = ['version', 'help'];
+export function parseParams(params) {
+    return Object.entries(params)
+        .filter(([key,]) => !EXCLUDED_PARAMS.includes(key))
+        .map(([key, val]) => {
+        if (typeof val === 'boolean' && !val) {
+            return '';
+        }
+        const vals = Array.isArray(val) ? val : [val];
+        return vals.map((v) => `--${decamelize(key, { separator: '-' })}${typeof v === 'boolean' ? '' : `=${v}`}`);
+    })
+        .flat()
+        .filter(Boolean);
+}
+export function getLocalChromePath() {
+    try {
+        const chromePath = getChromePath();
+        return chromePath;
+    }
+    catch (err) {
+        return;
+    }
+}
+export function getBuildIdByPath(chromePath) {
+    if (!chromePath) {
+        return;
+    }
+    else if (os.platform() === 'win32') {
+        const versionPath = path.dirname(chromePath);
+        const contents = fs.readdirSync(versionPath);
+        const versions = contents.filter(a => /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/g.test(a));
+        // returning oldest in case there is an updated version and chrome still hasn't relaunched
+        const oldest = versions.sort((a, b) => a > b ? -1 : 1)[0];
+        return oldest;
+    }
+    const versionString = cp.execSync(`"${chromePath}" --version`).toString();
+    return versionString.split(' ').pop()?.trim();
+}
+let lastTimeCalled = Date.now();
+export const downloadProgressCallback = (artifact, downloadedBytes, totalBytes) => {
+    if (Date.now() - lastTimeCalled < 1000) {
+        return;
+    }
+    const percentage = ((downloadedBytes / totalBytes) * 100).toFixed(2);
+    log.info(`Downloading ${artifact} ${percentage}%`);
+    lastTimeCalled = Date.now();
+};
+export async function setupChrome(cacheDir, caps) {
+    caps.browserName = caps.browserName?.toLowerCase();
+    const exist = await fsp.access(cacheDir).then(() => true, () => false);
+    if (!exist) {
+        await fsp.mkdir(cacheDir, { recursive: true });
+    }
+    const platform = detectBrowserPlatform();
+    if (!platform) {
+        throw new Error('The current platform is not supported.');
+    }
+    if (!caps.browserVersion) {
+        const executablePath = getLocalChromePath();
+        const tag = getBuildIdByPath(executablePath);
+        /**
+         * verify that we have a valid Chrome browser installed
+         */
+        if (tag) {
+            return {
+                cacheDir,
+                platform,
+                executablePath,
+                buildId: await resolveBuildId(Browser.CHROME, platform, tag)
+            };
+        }
+    }
+    /**
+     * otherwise download provided Chrome browser version or "stable"
+     */
+    const tag = caps.browserVersion || ChromeReleaseChannel.STABLE;
+    const buildId = await resolveBuildId(Browser.CHROME, platform, tag);
+    const installOptions = {
+        unpack: true,
+        cacheDir,
+        platform,
+        buildId,
+        browser: Browser.CHROME,
+        downloadProgressCallback: (downloadedBytes, totalBytes) => downloadProgressCallback('Chrome', downloadedBytes, totalBytes)
+    };
+    const isCombinationAvailable = await canDownload(installOptions);
+    if (!isCombinationAvailable) {
+        throw new Error(`Couldn't find a matching Chrome browser for tag "${buildId}" on platform "${platform}"`);
+    }
+    log.info(`Setting up Chrome v${buildId}`);
+    await install(installOptions);
+    const executablePath = computeExecutablePath(installOptions);
+    return { executablePath, browserVersion: buildId };
+}
+export function getCacheDir(options, caps) {
+    const driverOptions = (caps['wdio:chromedriverOptions'] ||
+        caps['wdio:chromedriverOptions'] ||
+        caps['wdio:chromedriverOptions'] ||
+        caps['wdio:chromedriverOptions'] ||
+        {});
+    return driverOptions.cacheDir || options.cacheDir || os.tmpdir();
+}
+export async function setupChromedriver(cacheDir, driverVersion) {
+    const platform = detectBrowserPlatform();
+    if (!platform) {
+        throw new Error('The current platform is not supported.');
+    }
+    const version = driverVersion || getBuildIdByPath(getLocalChromePath()) || ChromeReleaseChannel.STABLE;
+    const buildId = await resolveBuildId(Browser.CHROMEDRIVER, platform, version);
+    let executablePath = computeExecutablePath({
+        browser: Browser.CHROMEDRIVER,
+        buildId,
+        platform,
+        cacheDir
+    });
+    let loggedBuildId = buildId;
+    const hasChromedriverInstalled = await fsp.access(executablePath).then(() => true, () => false);
+    if (!hasChromedriverInstalled) {
+        log.info(`Downloading Chromedriver v${buildId}`);
+        const chromedriverInstallOpts = {
+            cacheDir,
+            buildId,
+            platform,
+            browser: Browser.CHROMEDRIVER,
+            unpack: true,
+            downloadProgressCallback: (downloadedBytes, totalBytes) => downloadProgressCallback('Chromedriver', downloadedBytes, totalBytes)
+        };
+        try {
+            await install({ ...chromedriverInstallOpts, buildId });
+        }
+        catch (err) {
+            /**
+             * in case we detect a Chrome browser installed for which there is no Chromedriver available
+             * we are falling back to the latest known good version
+             */
+            log.warn(`Couldn't download Chromedriver v${buildId}: ${err.message}, trying to find known good version...`);
+            let knownGoodVersion;
+            if (buildId.includes('.')) {
+                const majorVersion = buildId.split('.')[0];
+                const knownGoodVersions = await got('https://googlechromelabs.github.io/chrome-for-testing/known-good-versions.json').json();
+                const versionMatch = knownGoodVersions.versions.filter(({ version }) => version.startsWith(majorVersion)).pop();
+                if (!versionMatch) {
+                    throw new Error(`Couldn't find known good version for Chromedriver v${majorVersion}`);
+                }
+                knownGoodVersion = versionMatch.version;
+            }
+            else {
+                knownGoodVersion = await resolveBuildId(Browser.CHROMEDRIVER, platform, buildId);
+            }
+            loggedBuildId = knownGoodVersion;
+            await install({ ...chromedriverInstallOpts, buildId: loggedBuildId });
+            executablePath = computeExecutablePath({
+                browser: Browser.CHROMEDRIVER,
+                buildId: loggedBuildId,
+                platform,
+                cacheDir
+            });
+        }
+    }
+    else {
+        log.info(`Using Chromedriver v${buildId} from cache directory ${cacheDir}`);
+    }
+    return { executablePath };
+}
+export function setupGeckodriver(cacheDir, driverVersion) {
+    return downloadGeckodriver(driverVersion, cacheDir);
+}
+export function setupEdgedriver(cacheDir, driverVersion) {
+    return downloadEdgedriver(driverVersion, cacheDir);
+}
+/**
+ * helper method to determine if we need to start a browser driver
+ * which is: whenever the user has set connection options that differ from
+ * the default, or a port is set
+ */
+export function definesRemoteDriver(options) {
+    return Boolean((options.protocol && options.protocol !== DEFAULT_PROTOCOL) ||
+        (options.hostname && options.hostname !== DEFAULT_HOSTNAME) ||
+        Boolean(options.port) ||
+        (options.path && options.path !== DEFAULT_PATH));
+}
+export function isChrome(browserName) {
+    return Boolean(browserName && SUPPORTED_BROWSERNAMES.chrome.includes(browserName.toLowerCase()));
+}
+export function isSafari(browserName) {
+    return Boolean(browserName && SUPPORTED_BROWSERNAMES.safari.includes(browserName.toLowerCase()));
+}
+export function isFirefox(browserName) {
+    return Boolean(browserName && SUPPORTED_BROWSERNAMES.firefox.includes(browserName.toLowerCase()));
+}
+export function isEdge(browserName) {
+    return Boolean(browserName && SUPPORTED_BROWSERNAMES.edge.includes(browserName.toLowerCase()));
+}

package/build/envDetector.js

@@ -57,9 +57,9 @@ function isChrome(capabilities) {
     return Boolean(capabilities.chrome || capabilities['goog:chromeOptions']);
 }
 /**
- * check if session is run by Chromedriver
+ * check if session is run by Geckodriver
  * @param  {Object}  capabilities  caps of session response
- * @return {Boolean}               true if run by Chromedriver
+ * @return {Boolean}               true if run by Geckodriver
  */
 function isFirefox(capabilities) {
     if (!capabilities) {

package/build/index.d.ts

@@ -5,8 +5,10 @@ import { commandCallStructure, isValidParameter, getArgumentType, safeImport, is
 import { wrapCommand, executeHooksWithArgs, executeAsync } from './shim.js';
 import { testFnWrapper, wrapGlobalTestMethod } from './test-framework/index.js';
 import { isW3C, capabilitiesEnvironmentDetector, sessionEnvironmentDetector, devtoolsEnvironmentDetector } from './envDetector.js';
+import { startWebDriver } from './driver/index.js';
+import { setupDriver, setupBrowser } from './driver/manager.js';
 import { UNICODE_CHARACTERS } from './constants.js';
-export { initialisePlugin, initialiseLauncherService, initialiseWorkerService, isFunctionAsync, transformCommandLogResult, webdriverMonad, commandCallStructure, isValidParameter, getArgumentType, safeImport, canAccess, sleep, 
+export { initialisePlugin, initialiseLauncherService, initialiseWorkerService, isFunctionAsync, transformCommandLogResult, webdriverMonad, commandCallStructure, isValidParameter, getArgumentType, safeImport, canAccess, sleep, startWebDriver, setupBrowser, setupDriver, 
 /**
  * runner shim
  */

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,gBAAgB,MAAM,uBAAuB,CAAA;AACpD,OAAO,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AAC5F,OAAO,cAAc,MAAM,YAAY,CAAA;AACvC,OAAO,EACH,oBAAoB,EAAE,gBAAgB,EAAE,eAAe,EAAE,UAAU,EACnE,eAAe,EAAE,yBAAyB,EAAE,SAAS,EAAE,KAAK,EAC/D,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAC3E,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAC/E,OAAO,EACH,KAAK,EAAE,+BAA+B,EACtC,0BAA0B,EAAE,2BAA2B,EAC1D,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,EACH,gBAAgB,EAChB,yBAAyB,EACzB,uBAAuB,EACvB,eAAe,EACf,yBAAyB,EACzB,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,UAAU,EACV,SAAS,EACT,KAAK;AAEL;;GAEG;AACH,WAAW,EACX,YAAY,EACZ,oBAAoB,EACpB,aAAa,EACb,oBAAoB;AAEpB;;GAEG;AACH,KAAK,EACL,0BAA0B,EAC1B,+BAA+B,EAC/B,2BAA2B;AAE3B;;GAEG;AACH,kBAAkB,EACrB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,gBAAgB,MAAM,uBAAuB,CAAA;AACpD,OAAO,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AAC5F,OAAO,cAAc,MAAM,YAAY,CAAA;AACvC,OAAO,EACH,oBAAoB,EAAE,gBAAgB,EAAE,eAAe,EAAE,UAAU,EACnE,eAAe,EAAE,yBAAyB,EAAE,SAAS,EAAE,KAAK,EAC/D,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAC3E,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAC/E,OAAO,EACH,KAAK,EAAE,+BAA+B,EACtC,0BAA0B,EAAE,2BAA2B,EAC1D,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAClD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,EACH,gBAAgB,EAChB,yBAAyB,EACzB,uBAAuB,EACvB,eAAe,EACf,yBAAyB,EACzB,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,UAAU,EACV,SAAS,EACT,KAAK,EACL,cAAc,EACd,YAAY,EACZ,WAAW;AAEX;;GAEG;AACH,WAAW,EACX,YAAY,EACZ,oBAAoB,EACpB,aAAa,EACb,oBAAoB;AAEpB;;GAEG;AACH,KAAK,EACL,0BAA0B,EAC1B,+BAA+B,EAC/B,2BAA2B;AAE3B;;GAEG;AACH,kBAAkB,EACrB,CAAA"}

package/build/index.js

@@ -6,8 +6,10 @@ import { commandCallStructure, isValidParameter, getArgumentType, safeImport, is
 import { wrapCommand, executeHooksWithArgs, executeAsync } from './shim.js';
 import { testFnWrapper, wrapGlobalTestMethod } from './test-framework/index.js';
 import { isW3C, capabilitiesEnvironmentDetector, sessionEnvironmentDetector, devtoolsEnvironmentDetector } from './envDetector.js';
+import { startWebDriver } from './driver/index.js';
+import { setupDriver, setupBrowser } from './driver/manager.js';
 import { UNICODE_CHARACTERS } from './constants.js';
-export { initialisePlugin, initialiseLauncherService, initialiseWorkerService, isFunctionAsync, transformCommandLogResult, webdriverMonad, commandCallStructure, isValidParameter, getArgumentType, safeImport, canAccess, sleep, 
+export { initialisePlugin, initialiseLauncherService, initialiseWorkerService, isFunctionAsync, transformCommandLogResult, webdriverMonad, commandCallStructure, isValidParameter, getArgumentType, safeImport, canAccess, sleep, startWebDriver, setupBrowser, setupDriver, 
 /**
  * runner shim
  */

package/build/shim.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shim.d.ts","sourceRoot":"","sources":["../src/shim.ts"],"names":[],"mappings":"AAQA,UAAU,OAAO;IACb,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACnB;AAED,OAAO,CAAC,MAAM,CAAC;IAEX,IAAI,WAAW,EAAE,GAAG,CAAA;CACvB;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,MAAM,CAAC;QACb,UAAU,MAAM;YACZ,MAAM,EAAE,GAAG,CAAA;YACX,WAAW,EAAE,GAAG,CAAA;SACnB;KACJ;CACJ;AAaD,QAAA,MAAM,oBAAoB,YAAqD,GAAG,YAAY,MAAM,UAAS,QAAQ,GAAG,QAAQ,EAAE,SAAa,GAAG,EAAE,2BA6CnJ,CAAA;AAED;;;;GAIG;AACH,QAAA,MAAM,WAAW,mBAAwC,MAAM,MAAM,QAAQ,eAAa,GAAG,eAkL5F,CAAA;AAED;;;;;;;GAOG;AACH,iBAAe,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,GAAE,GAAG,EAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBzG;AAED,OAAO,EACH,oBAAoB,EACpB,WAAW,EACX,YAAY,GACf,CAAA"}
+{"version":3,"file":"shim.d.ts","sourceRoot":"","sources":["../src/shim.ts"],"names":[],"mappings":"AASA,UAAU,OAAO;IACb,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACnB;AAED,OAAO,CAAC,MAAM,CAAC;IAEX,IAAI,WAAW,EAAE,GAAG,CAAA;CACvB;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,MAAM,CAAC;QACb,UAAU,MAAM;YACZ,MAAM,EAAE,GAAG,CAAA;YACX,WAAW,EAAE,GAAG,CAAA;SACnB;KACJ;CACJ;AAaD,QAAA,MAAM,oBAAoB,YAAqD,GAAG,YAAY,MAAM,UAAS,QAAQ,GAAG,QAAQ,EAAE,SAAa,GAAG,EAAE,2BA6CnJ,CAAA;AAED;;;;GAIG;AACH,QAAA,MAAM,WAAW,mBAAwC,MAAM,MAAM,QAAQ,eAAa,GAAG,eAkL5F,CAAA;AAED;;;;;;;GAOG;AACH,iBAAe,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,GAAE,GAAG,EAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBzG;AAED,OAAO,EACH,oBAAoB,EACpB,WAAW,EACX,YAAY,GACf,CAAA"}

package/build/shim.js

@@ -1,5 +1,5 @@
-import * as iterators from './pIteration.js';
 import logger from '@wdio/logger';
+import * as iterators from './pIteration.js';
 const log = logger('@wdio/utils:shim');
 let inCommandHook = false;
 const ELEMENT_QUERY_COMMANDS = [

package/build/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAW,MAAM,aAAa,CAAA;AAMpD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,gBAAgB,EAAE;IAAE,sBAAsB,CAAC,EAAE;QAAE,KAAK,EAAE,GAAG,CAAA;KAAE,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,QAwCzH;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAE,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,MAAM,UAAQ,UA+BrF;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAE,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE;;;EAapF;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAE,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,WA8B/D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAE,GAAG,EAAE,GAAG,wGAExC;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,aAAa,GAAG,IAAI,CAAC,CA4DtF;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAE,EAAE,EAAE,QAAQ,WAE5C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAE,IAAI,EAAE,GAAG,EAAE,SAE1C;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,WAenC;AAED;;;;GAIG;AACH,eAAO,MAAM,SAAS,UAAW,MAAM,YAWtC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,KAAK,mCAAoD,CAAA"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAW,MAAM,aAAa,CAAA;AAMpD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,gBAAgB,EAAE;IAAE,sBAAsB,CAAC,EAAE;QAAE,KAAK,EAAE,GAAG,CAAA;KAAE,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,QAwCzH;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAE,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,MAAM,UAAQ,UA+BrF;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAE,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE;;;EAapF;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAE,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,WA8B/D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAE,GAAG,EAAE,GAAG,wGAExC;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,aAAa,GAAG,IAAI,CAAC,CA2DtF;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAE,EAAE,EAAE,QAAQ,WAE5C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAE,IAAI,EAAE,GAAG,EAAE,SAE1C;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,WAenC;AAED;;;;GAIG;AACH,eAAO,MAAM,SAAS,UAAW,MAAM,YAWtC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,KAAK,mCAAoD,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wdio/utils",
-  "version": "8.13.13",
+  "version": "8.15.0",
   "description": "A WDIO helper utility to provide several utility functions used across the project.",
   "author": "Christian Bromann <mail@bromann.dev>",
   "homepage": "https://github.com/webdriverio/webdriverio/tree/main/packages/wdio-utils",
@@ -30,12 +30,22 @@
     "url": "https://github.com/webdriverio/webdriverio/issues"
   },
   "dependencies": {
+    "@puppeteer/browsers": "^1.6.0",
     "@wdio/logger": "8.11.0",
-    "@wdio/types": "8.10.4",
-    "import-meta-resolve": "^3.0.0"
+    "@wdio/types": "8.15.0",
+    "chrome-launcher": "^1.0.0",
+    "decamelize": "^6.0.0",
+    "deepmerge-ts": "^5.1.0",
+    "edgedriver": "^5.3.3",
+    "geckodriver": "^4.2.0",
+    "get-port": "^7.0.0",
+    "got": "^13.0.0",
+    "import-meta-resolve": "^3.0.0",
+    "safaridriver": "^0.1.0",
+    "wait-port": "^1.0.4"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ba97a49a1294e812ed35fc05be20dd29133ab200"
+  "gitHead": "78e199c5ffd74bdf3a5576952c3834c29afa989f"
 }