@ejazullah/browser-mcp 0.0.56

package/lib/auth.js

@@ -0,0 +1,82 @@
+/**
+ * External API Key Authentication
+ *
+ * Validates API keys against the external auth provider:
+ * POST https://system-mangment-app.vercel.app/api/validate
+ * Headers: { "X-API-KEY": "<key>" }
+ */
+const VALIDATE_URL = process.env.VALIDATE_URL || 'https://nexviahub.vercel.app/functions/v1/api-keys';
+const CACHE_TTL_MS = 2 * 60 * 1000; // 2 minutes
+const validationCache = new Map();
+// ─── Core Validator ──────────────────────────────────────────────────────────
+/**
+ * Validate an API key against the external auth provider.
+ * Results are cached for 5 minutes to reduce external API calls.
+ */
+export async function validateApiKey(apiKey) {
+    const cached = validationCache.get(apiKey);
+    if (cached && Date.now() < cached.expiresAt)
+        return cached.valid;
+    let valid = false;
+    try {
+        const response = await fetch(VALIDATE_URL, {
+            method: 'POST',
+            headers: { 'X-API-KEY': apiKey },
+            body: JSON.stringify({ "action": "authorize" })
+        });
+        valid = response.ok;
+    }
+    catch {
+        valid = false;
+    }
+    validationCache.set(apiKey, { valid, expiresAt: Date.now() + CACHE_TTL_MS });
+    return valid;
+}
+// ─── HTTP Middleware ──────────────────────────────────────────────────────────
+/**
+ * Authenticate an incoming HTTP request.
+ * Reads the X-API-KEY header and validates it against the external provider.
+ * Returns false if authenticated (request may proceed).
+ * Returns true if authentication failed (error response already sent).
+ */
+export async function authenticateRequest(req, res) {
+    const apiKey = req.headers['x-api-key'];
+    if (!apiKey) {
+        res.setHeader('WWW-Authenticate', 'ApiKey realm="mcp-playwright"');
+        sendJsonResponse(res, 401, {
+            error: 'unauthorized',
+            error_description: 'Authentication required. Provide your API key via the X-API-KEY header.',
+        });
+        return true;
+    }
+    const valid = await validateApiKey(apiKey);
+    if (!valid) {
+        sendJsonResponse(res, 401, {
+            error: 'invalid_api_key',
+            error_description: 'The provided API key is invalid or has been revoked.',
+        });
+        return true;
+    }
+    return false; // authenticated
+}
+// ─── Utilities ───────────────────────────────────────────────────────────────
+function sendJsonResponse(res, status, body) {
+    res.setHeader('Content-Type', 'application/json');
+    res.statusCode = status;
+    res.end(JSON.stringify(body));
+}
+export function defaultAuthConfig() {
+    return { enabled: true };
+}
+export function buildAuthConfig(_options) {
+    return { enabled: true };
+}
+export class AuthManager {
+    constructor(_config) { }
+    get enabled() {
+        return true;
+    }
+    async authenticateRequest(req, res) {
+        return authenticateRequest(req, res);
+    }
+}

package/lib/browserContextFactory.js

@@ -0,0 +1,205 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import fs from 'fs';
+import net from 'net';
+import path from 'path';
+import * as playwright from 'playwright';
+// @ts-ignore
+import { registryDirectory } from 'playwright-core/lib/server/registry/index';
+import { logUnhandledError, testDebug } from './log.js';
+import { createHash } from './utils.js';
+import { outputFile } from './config.js';
+export function contextFactory(config) {
+    if (config.browser.remoteEndpoint)
+        return new RemoteContextFactory(config);
+    if (config.browser.cdpEndpoint)
+        return new CdpContextFactory(config);
+    if (config.browser.isolated)
+        return new IsolatedContextFactory(config);
+    return new PersistentContextFactory(config);
+}
+class BaseContextFactory {
+    name;
+    description;
+    config;
+    _browserPromise;
+    _tracesDir;
+    constructor(name, description, config) {
+        this.name = name;
+        this.description = description;
+        this.config = config;
+    }
+    async _obtainBrowser() {
+        if (this._browserPromise)
+            return this._browserPromise;
+        testDebug(`obtain browser (${this.name})`);
+        this._browserPromise = this._doObtainBrowser();
+        void this._browserPromise.then(browser => {
+            browser.on('disconnected', () => {
+                this._browserPromise = undefined;
+            });
+        }).catch(() => {
+            this._browserPromise = undefined;
+        });
+        return this._browserPromise;
+    }
+    async _doObtainBrowser() {
+        throw new Error('Not implemented');
+    }
+    async createContext(clientInfo) {
+        if (this.config.saveTrace)
+            this._tracesDir = await outputFile(this.config, clientInfo.rootPath, `traces-${Date.now()}`);
+        testDebug(`create browser context (${this.name})`);
+        const browser = await this._obtainBrowser();
+        const browserContext = await this._doCreateContext(browser);
+        return { browserContext, close: () => this._closeBrowserContext(browserContext, browser) };
+    }
+    async _doCreateContext(browser) {
+        throw new Error('Not implemented');
+    }
+    async _closeBrowserContext(browserContext, browser) {
+        testDebug(`close browser context (${this.name})`);
+        if (browser.contexts().length === 1)
+            this._browserPromise = undefined;
+        await browserContext.close().catch(logUnhandledError);
+        if (browser.contexts().length === 0) {
+            testDebug(`close browser (${this.name})`);
+            await browser.close().catch(logUnhandledError);
+        }
+    }
+}
+class IsolatedContextFactory extends BaseContextFactory {
+    constructor(config) {
+        super('isolated', 'Create a new isolated browser context', config);
+    }
+    async _doObtainBrowser() {
+        await injectCdpPort(this.config.browser);
+        const browserType = playwright[this.config.browser.browserName];
+        return browserType.launch({
+            tracesDir: this._tracesDir,
+            ...this.config.browser.launchOptions,
+            handleSIGINT: false,
+            handleSIGTERM: false,
+        }).catch(error => {
+            if (error.message.includes('Executable doesn\'t exist'))
+                throw new Error(`Browser specified in your config is not installed. Either install it (likely) or change the config.`);
+            throw error;
+        });
+    }
+    async _doCreateContext(browser) {
+        return browser.newContext(this.config.browser.contextOptions);
+    }
+}
+class CdpContextFactory extends BaseContextFactory {
+    constructor(config) {
+        super('cdp', 'Connect to a browser over CDP', config);
+    }
+    async _doObtainBrowser() {
+        return playwright.chromium.connectOverCDP(this.config.browser.cdpEndpoint);
+    }
+    async _doCreateContext(browser) {
+        return this.config.browser.isolated ? await browser.newContext() : browser.contexts()[0];
+    }
+}
+class RemoteContextFactory extends BaseContextFactory {
+    constructor(config) {
+        super('remote', 'Connect to a browser using a remote endpoint', config);
+    }
+    async _doObtainBrowser() {
+        const url = new URL(this.config.browser.remoteEndpoint);
+        url.searchParams.set('browser', this.config.browser.browserName);
+        if (this.config.browser.launchOptions)
+            url.searchParams.set('launch-options', JSON.stringify(this.config.browser.launchOptions));
+        return playwright[this.config.browser.browserName].connect(String(url));
+    }
+    async _doCreateContext(browser) {
+        return browser.newContext();
+    }
+}
+class PersistentContextFactory {
+    config;
+    name = 'persistent';
+    description = 'Create a new persistent browser context';
+    _userDataDirs = new Set();
+    constructor(config) {
+        this.config = config;
+    }
+    async createContext(clientInfo) {
+        await injectCdpPort(this.config.browser);
+        testDebug('create browser context (persistent)');
+        const userDataDir = this.config.browser.userDataDir ?? await this._createUserDataDir(clientInfo.rootPath);
+        let tracesDir;
+        if (this.config.saveTrace)
+            tracesDir = await outputFile(this.config, clientInfo.rootPath, `traces-${Date.now()}`);
+        this._userDataDirs.add(userDataDir);
+        testDebug('lock user data dir', userDataDir);
+        const browserType = playwright[this.config.browser.browserName];
+        for (let i = 0; i < 5; i++) {
+            try {
+                const browserContext = await browserType.launchPersistentContext(userDataDir, {
+                    tracesDir,
+                    ...this.config.browser.launchOptions,
+                    ...this.config.browser.contextOptions,
+                    handleSIGINT: false,
+                    handleSIGTERM: false,
+                });
+                const close = () => this._closeBrowserContext(browserContext, userDataDir);
+                return { browserContext, close };
+            }
+            catch (error) {
+                if (error.message.includes('Executable doesn\'t exist'))
+                    throw new Error(`Browser specified in your config is not installed. Either install it (likely) or change the config.`);
+                if (error.message.includes('ProcessSingleton') || error.message.includes('Invalid URL')) {
+                    // User data directory is already in use, try again.
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw new Error(`Browser is already in use for ${userDataDir}, use --isolated to run multiple instances of the same browser`);
+    }
+    async _closeBrowserContext(browserContext, userDataDir) {
+        testDebug('close browser context (persistent)');
+        testDebug('release user data dir', userDataDir);
+        await browserContext.close().catch(() => { });
+        this._userDataDirs.delete(userDataDir);
+        testDebug('close browser context complete (persistent)');
+    }
+    async _createUserDataDir(rootPath) {
+        const dir = process.env.PWMCP_PROFILES_DIR_FOR_TEST ?? registryDirectory;
+        const browserToken = this.config.browser.launchOptions?.channel ?? this.config.browser?.browserName;
+        // Hesitant putting hundreds of files into the user's workspace, so using it for hashing instead.
+        const rootPathToken = rootPath ? `-${createHash(rootPath)}` : '';
+        const result = path.join(dir, `mcp-${browserToken}${rootPathToken}`);
+        await fs.promises.mkdir(result, { recursive: true });
+        return result;
+    }
+}
+async function injectCdpPort(browserConfig) {
+    if (browserConfig.browserName === 'chromium')
+        browserConfig.launchOptions.cdpPort = await findFreePort();
+}
+async function findFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.listen(0, () => {
+            const { port } = server.address();
+            server.close(() => resolve(port));
+        });
+        server.on('error', reject);
+    });
+}

package/lib/browserServerBackend.js

@@ -0,0 +1,125 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { fileURLToPath } from 'url';
+import { z } from 'zod';
+import { Context } from './context.js';
+import { logUnhandledError } from './log.js';
+import { Response } from './response.js';
+import { SessionLog } from './sessionLog.js';
+import { filteredTools } from './tools.js';
+import { packageJSON } from './package.js';
+import { defineTool } from './tools/tool.js';
+export class BrowserServerBackend {
+    name = 'Playwright';
+    version = packageJSON.version;
+    _tools;
+    _context;
+    _sessionLog;
+    _config;
+    _browserContextFactory;
+    constructor(config, factories) {
+        this._config = config;
+        this._browserContextFactory = factories[0];
+        this._tools = filteredTools(config);
+        if (factories.length > 1)
+            this._tools.push(this._defineContextSwitchTool(factories));
+    }
+    async initialize(server) {
+        const capabilities = server.getClientCapabilities();
+        let rootPath;
+        if (capabilities.roots && (server.getClientVersion()?.name === 'Visual Studio Code' ||
+            server.getClientVersion()?.name === 'Visual Studio Code - Insiders')) {
+            const { roots } = await server.listRoots();
+            const firstRootUri = roots[0]?.uri;
+            const url = firstRootUri ? new URL(firstRootUri) : undefined;
+            rootPath = url ? fileURLToPath(url) : undefined;
+        }
+        this._sessionLog = this._config.saveSession ? await SessionLog.create(this._config, rootPath) : undefined;
+        this._context = new Context({
+            tools: this._tools,
+            config: this._config,
+            browserContextFactory: this._browserContextFactory,
+            sessionLog: this._sessionLog,
+            clientInfo: { ...server.getClientVersion(), rootPath },
+        });
+    }
+    tools() {
+        return this._tools.map(tool => tool.schema);
+    }
+    async callTool(schema, parsedArguments) {
+        const context = this._context;
+        const response = new Response(context, schema.name, parsedArguments);
+        const tool = this._tools.find(tool => tool.schema.name === schema.name);
+        context.setRunningTool(true);
+        try {
+            await tool.handle(context, parsedArguments, response);
+            await response.finish();
+            this._sessionLog?.logResponse(response);
+        }
+        catch (error) {
+            response.addError(String(error));
+        }
+        finally {
+            context.setRunningTool(false);
+        }
+        return response.serialize();
+    }
+    serverClosed() {
+        try {
+            void this._context?.dispose().catch(logUnhandledError);
+        }
+        catch {
+        }
+    }
+    _defineContextSwitchTool(factories) {
+        const self = this;
+        return defineTool({
+            capability: 'core',
+            schema: {
+                name: 'browser_connect',
+                title: 'Connect to a browser context',
+                description: [
+                    'Connect to a browser using one of the available methods:',
+                    ...factories.map(factory => `- "${factory.name}": ${factory.description}`),
+                ].join('\n'),
+                inputSchema: z.object({
+                    method: z.enum(factories.map(factory => factory.name)).default(factories[0].name).describe('The method to use to connect to the browser'),
+                }),
+                type: 'readOnly',
+            },
+            async handle(context, params, response) {
+                const factory = factories.find(factory => factory.name === params.method);
+                if (!factory) {
+                    response.addError('Unknown connection method: ' + params.method);
+                    return;
+                }
+                await self._setContextFactory(factory);
+                response.addResult('Successfully changed connection method.');
+            }
+        });
+    }
+    async _setContextFactory(newFactory) {
+        if (this._context) {
+            const options = {
+                ...this._context.options,
+                browserContextFactory: newFactory,
+            };
+            await this._context.dispose();
+            this._context = new Context(options);
+        }
+        this._browserContextFactory = newFactory;
+    }
+}

package/lib/config.js

@@ -0,0 +1,266 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { devices } from 'playwright';
+import { sanitizeForFilePath } from './utils.js';
+const defaultConfig = {
+    browser: {
+        browserName: 'chromium',
+        launchOptions: {
+            channel: 'chrome',
+            headless: os.platform() === 'linux' && !process.env.DISPLAY,
+            chromiumSandbox: true,
+        },
+        contextOptions: {
+            viewport: null,
+        },
+    },
+    network: {
+        allowedOrigins: undefined,
+        blockedOrigins: undefined,
+    },
+    server: {},
+    saveTrace: false,
+};
+export async function resolveConfig(config) {
+    return mergeConfig(defaultConfig, config);
+}
+export async function resolveCLIConfig(cliOptions) {
+    const configInFile = await loadConfig(cliOptions.config);
+    const envOverrides = configFromEnv();
+    const cliOverrides = configFromCLIOptions(cliOptions);
+    let result = defaultConfig;
+    result = mergeConfig(result, configInFile);
+    result = mergeConfig(result, envOverrides);
+    result = mergeConfig(result, cliOverrides);
+    return result;
+}
+export function configFromCLIOptions(cliOptions) {
+    let browserName;
+    let channel;
+    switch (cliOptions.browser) {
+        case 'chrome':
+        case 'chrome-beta':
+        case 'chrome-canary':
+        case 'chrome-dev':
+        case 'chromium':
+        case 'msedge':
+        case 'msedge-beta':
+        case 'msedge-canary':
+        case 'msedge-dev':
+            browserName = 'chromium';
+            channel = cliOptions.browser;
+            break;
+        case 'firefox':
+            browserName = 'firefox';
+            break;
+        case 'webkit':
+            browserName = 'webkit';
+            break;
+    }
+    // Launch options
+    const launchOptions = {
+        channel,
+        executablePath: cliOptions.executablePath,
+        headless: cliOptions.headless,
+    };
+    // --no-sandbox was passed, disable the sandbox
+    if (cliOptions.sandbox === false)
+        launchOptions.chromiumSandbox = false;
+    if (cliOptions.proxyServer) {
+        launchOptions.proxy = {
+            server: cliOptions.proxyServer
+        };
+        if (cliOptions.proxyBypass)
+            launchOptions.proxy.bypass = cliOptions.proxyBypass;
+    }
+    if (cliOptions.device && cliOptions.cdpEndpoint)
+        throw new Error('Device emulation is not supported with cdpEndpoint.');
+    // Context options
+    const contextOptions = cliOptions.device ? devices[cliOptions.device] : {};
+    if (cliOptions.storageState)
+        contextOptions.storageState = cliOptions.storageState;
+    if (cliOptions.userAgent)
+        contextOptions.userAgent = cliOptions.userAgent;
+    if (cliOptions.viewportSize) {
+        try {
+            const [width, height] = cliOptions.viewportSize.split(',').map(n => +n);
+            if (isNaN(width) || isNaN(height))
+                throw new Error('bad values');
+            contextOptions.viewport = { width, height };
+        }
+        catch (e) {
+            throw new Error('Invalid viewport size format: use "width,height", for example --viewport-size="800,600"');
+        }
+    }
+    if (cliOptions.ignoreHttpsErrors)
+        contextOptions.ignoreHTTPSErrors = true;
+    if (cliOptions.blockServiceWorkers)
+        contextOptions.serviceWorkers = 'block';
+    const result = {
+        browser: {
+            browserName,
+            isolated: cliOptions.isolated,
+            userDataDir: cliOptions.userDataDir,
+            launchOptions,
+            contextOptions,
+            cdpEndpoint: cliOptions.cdpEndpoint,
+        },
+        server: {
+            port: cliOptions.port,
+            host: cliOptions.host,
+        },
+        capabilities: cliOptions.caps,
+        network: {
+            allowedOrigins: cliOptions.allowedOrigins,
+            blockedOrigins: cliOptions.blockedOrigins,
+        },
+        saveSession: cliOptions.saveSession,
+        saveTrace: cliOptions.saveTrace,
+        outputDir: cliOptions.outputDir,
+        imageResponses: cliOptions.imageResponses,
+        mongodb: {
+            url: cliOptions.mongodbUrl,
+            dbName: cliOptions.mongodbDb,
+            collectionName: cliOptions.mongodbCollection,
+        },
+        auth: {
+            enabled: cliOptions.auth,
+            jwtSecret: cliOptions.jwtSecret,
+            tokenExpiry: cliOptions.tokenExpiry,
+            apiKeys: cliOptions.apiKeys,
+            oauthClients: cliOptions.oauthClients,
+        },
+    };
+    return result;
+}
+function configFromEnv() {
+    const options = {};
+    options.allowedOrigins = semicolonSeparatedList(process.env.PLAYWRIGHT_MCP_ALLOWED_ORIGINS);
+    options.blockedOrigins = semicolonSeparatedList(process.env.PLAYWRIGHT_MCP_BLOCKED_ORIGINS);
+    options.blockServiceWorkers = envToBoolean(process.env.PLAYWRIGHT_MCP_BLOCK_SERVICE_WORKERS);
+    options.browser = envToString(process.env.PLAYWRIGHT_MCP_BROWSER);
+    options.caps = commaSeparatedList(process.env.PLAYWRIGHT_MCP_CAPS);
+    options.cdpEndpoint = envToString(process.env.PLAYWRIGHT_MCP_CDP_ENDPOINT);
+    options.config = envToString(process.env.PLAYWRIGHT_MCP_CONFIG);
+    options.device = envToString(process.env.PLAYWRIGHT_MCP_DEVICE);
+    options.executablePath = envToString(process.env.PLAYWRIGHT_MCP_EXECUTABLE_PATH);
+    options.headless = envToBoolean(process.env.PLAYWRIGHT_MCP_HEADLESS);
+    options.host = envToString(process.env.PLAYWRIGHT_MCP_HOST);
+    options.ignoreHttpsErrors = envToBoolean(process.env.PLAYWRIGHT_MCP_IGNORE_HTTPS_ERRORS);
+    options.isolated = envToBoolean(process.env.PLAYWRIGHT_MCP_ISOLATED);
+    if (process.env.PLAYWRIGHT_MCP_IMAGE_RESPONSES === 'omit')
+        options.imageResponses = 'omit';
+    options.sandbox = envToBoolean(process.env.PLAYWRIGHT_MCP_SANDBOX);
+    options.outputDir = envToString(process.env.PLAYWRIGHT_MCP_OUTPUT_DIR);
+    options.port = envToNumber(process.env.PLAYWRIGHT_MCP_PORT);
+    options.proxyBypass = envToString(process.env.PLAYWRIGHT_MCP_PROXY_BYPASS);
+    options.proxyServer = envToString(process.env.PLAYWRIGHT_MCP_PROXY_SERVER);
+    options.saveTrace = envToBoolean(process.env.PLAYWRIGHT_MCP_SAVE_TRACE);
+    options.storageState = envToString(process.env.PLAYWRIGHT_MCP_STORAGE_STATE);
+    options.userAgent = envToString(process.env.PLAYWRIGHT_MCP_USER_AGENT);
+    options.userDataDir = envToString(process.env.PLAYWRIGHT_MCP_USER_DATA_DIR);
+    options.viewportSize = envToString(process.env.PLAYWRIGHT_MCP_VIEWPORT_SIZE);
+    options.mongodbUrl = envToString(process.env.MONGODB_URL);
+    options.mongodbDb = envToString(process.env.MONGODB_DB_NAME);
+    options.mongodbCollection = envToString(process.env.MONGODB_COLLECTION);
+    options.auth = envToBoolean(process.env.MCP_AUTH_ENABLED);
+    options.jwtSecret = envToString(process.env.MCP_JWT_SECRET);
+    options.tokenExpiry = envToString(process.env.MCP_TOKEN_EXPIRY);
+    options.apiKeys = envToString(process.env.MCP_API_KEYS);
+    options.oauthClients = envToString(process.env.MCP_OAUTH_CLIENTS);
+    return configFromCLIOptions(options);
+}
+async function loadConfig(configFile) {
+    if (!configFile)
+        return {};
+    try {
+        return JSON.parse(await fs.promises.readFile(configFile, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`Failed to load config file: ${configFile}, ${error}`);
+    }
+}
+export async function outputFile(config, rootPath, name) {
+    const outputDir = config.outputDir
+        ?? (rootPath ? path.join(rootPath, '.playwright-mcp') : undefined)
+        ?? path.join(os.tmpdir(), 'playwright-mcp-output', sanitizeForFilePath(new Date().toISOString()));
+    await fs.promises.mkdir(outputDir, { recursive: true });
+    const fileName = sanitizeForFilePath(name);
+    return path.join(outputDir, fileName);
+}
+function pickDefined(obj) {
+    return Object.fromEntries(Object.entries(obj ?? {}).filter(([_, v]) => v !== undefined));
+}
+function mergeConfig(base, overrides) {
+    const browser = {
+        ...pickDefined(base.browser),
+        ...pickDefined(overrides.browser),
+        browserName: overrides.browser?.browserName ?? base.browser?.browserName ?? 'chromium',
+        isolated: overrides.browser?.isolated ?? base.browser?.isolated ?? false,
+        launchOptions: {
+            ...pickDefined(base.browser?.launchOptions),
+            ...pickDefined(overrides.browser?.launchOptions),
+            ...{ assistantMode: true },
+        },
+        contextOptions: {
+            ...pickDefined(base.browser?.contextOptions),
+            ...pickDefined(overrides.browser?.contextOptions),
+        },
+    };
+    if (browser.browserName !== 'chromium' && browser.launchOptions)
+        delete browser.launchOptions.channel;
+    return {
+        ...pickDefined(base),
+        ...pickDefined(overrides),
+        browser,
+        network: {
+            ...pickDefined(base.network),
+            ...pickDefined(overrides.network),
+        },
+        server: {
+            ...pickDefined(base.server),
+            ...pickDefined(overrides.server),
+        },
+    };
+}
+export function semicolonSeparatedList(value) {
+    if (!value)
+        return undefined;
+    return value.split(';').map(v => v.trim());
+}
+export function commaSeparatedList(value) {
+    if (!value)
+        return undefined;
+    return value.split(',').map(v => v.trim());
+}
+function envToNumber(value) {
+    if (!value)
+        return undefined;
+    return +value;
+}
+function envToBoolean(value) {
+    if (value === 'true' || value === '1')
+        return true;
+    if (value === 'false' || value === '0')
+        return false;
+    return undefined;
+}
+function envToString(value) {
+    return value ? value.trim() : undefined;
+}