@wordbricks/playwright-mcp 0.1.20 → 0.1.23

package/lib/browserContextFactory.js

@@ -1,326 +0,0 @@
-/**
- * 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-core';
-import ms from 'ms';
-// @ts-ignore
-import { registryDirectory } from 'playwright-core/lib/server/registry/index';
-// @ts-ignore
-import { startTraceViewerServer } from 'playwright-core/lib/server';
-import { logUnhandledError, testDebug } from './utils/log.js';
-import { createHash } from './utils/guid.js';
-import { outputFile } from './config.js';
-const TIMEOUT_STR = '30m';
-async function applyInitScript(browserContext, config) {
-    if (config.browser.initScript) {
-        const scriptContent = await fs.promises.readFile(config.browser.initScript, 'utf8');
-        await browserContext.addInitScript(scriptContent);
-    }
-}
-async function hidePlaywrightMarkers(browserContext) {
-    await browserContext.addInitScript(() => {
-        // Delete the property if it exists
-        delete window.__pwInitScripts;
-        // Redefine `Object.getOwnPropertyNames`
-        const originalGetOwnPropertyNames = Object.getOwnPropertyNames;
-        Object.getOwnPropertyNames = (obj) => {
-            const props = originalGetOwnPropertyNames(obj);
-            return props.filter((prop) => prop !== '__pwInitScripts');
-        };
-        // Use a Proxy to handle access to `window`
-        const windowHandler = {
-            get(target, prop) {
-                if (prop === '__pwInitScripts')
-                    return undefined; // Hide the property
-                return Reflect.get(target, prop);
-            },
-            has(target, prop) {
-                if (prop === '__pwInitScripts')
-                    return false; // Prevent detection via "in" operator
-                return Reflect.has(target, prop);
-            },
-        };
-        const proxiedWindow = new Proxy(window, windowHandler);
-        Object.defineProperty(globalThis, 'window', {
-            value: proxiedWindow,
-            configurable: false,
-            writable: false,
-        });
-    });
-}
-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;
-    _autoCloseTimer;
-    description;
-    config;
-    _browserPromise;
-    constructor(name, description, config) {
-        this.name = name;
-        this.description = description;
-        this.config = config;
-    }
-    async _obtainBrowser(clientInfo) {
-        if (this._browserPromise)
-            return this._browserPromise;
-        testDebug(`obtain browser (${this.name})`);
-        this._browserPromise = this._doObtainBrowser(clientInfo);
-        void this._browserPromise.then(browser => {
-            browser.on('disconnected', () => {
-                this._browserPromise = undefined;
-                this._clearAutoCloseTimer();
-            });
-            // Start auto-close timer
-            this._startAutoCloseTimer(browser);
-        }).catch(() => {
-            this._browserPromise = undefined;
-            this._clearAutoCloseTimer();
-        });
-        return this._browserPromise;
-    }
-    _startAutoCloseTimer(browser) {
-        this._clearAutoCloseTimer();
-        testDebug(`schedule auto-close in ${TIMEOUT_STR} (${this.name})`);
-        this._autoCloseTimer = setTimeout(async () => {
-            testDebug(`auto-closing browser after ${TIMEOUT_STR} (${this.name})`);
-            try {
-                await browser.close();
-                this._browserPromise = undefined;
-                testDebug(`auto-close complete (${this.name})`);
-            }
-            catch (error) {
-                testDebug(`error during auto-close: ${error}`);
-            }
-        }, ms(TIMEOUT_STR));
-    }
-    _clearAutoCloseTimer() {
-        if (this._autoCloseTimer) {
-            testDebug(`cancel auto-close timer (${this.name})`);
-            clearTimeout(this._autoCloseTimer);
-            this._autoCloseTimer = undefined;
-        }
-    }
-    async _doObtainBrowser(clientInfo) {
-        throw new Error('Not implemented');
-    }
-    async createContext(clientInfo) {
-        testDebug(`create browser context (${this.name})`);
-        const browser = await this._obtainBrowser(clientInfo);
-        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;
-            this._clearAutoCloseTimer();
-        }
-        await browserContext.close().catch(logUnhandledError);
-        if (browser.contexts().length === 0) {
-            testDebug(`close browser (${this.name})`);
-            this._clearAutoCloseTimer();
-            await browser.close().catch(logUnhandledError);
-        }
-    }
-}
-class IsolatedContextFactory extends BaseContextFactory {
-    constructor(config) {
-        super('isolated', 'Create a new isolated browser context', config);
-    }
-    async _doObtainBrowser(clientInfo) {
-        await injectCdpPort(this.config.browser);
-        const browserType = playwright[this.config.browser.browserName];
-        return browserType.launch({
-            tracesDir: await startTraceServer(this.config, clientInfo.rootPath),
-            ...this.config.browser.launchOptions,
-            handleSIGINT: false,
-            handleSIGTERM: false,
-            args: this.config.browser.launchOptions?.args || [],
-        }).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) {
-        const browserContext = await browser.newContext(this.config.browser.contextOptions);
-        await applyInitScript(browserContext, this.config);
-        await hidePlaywrightMarkers(browserContext);
-        return browserContext;
-    }
-}
-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) {
-        const browserContext = this.config.browser.isolated ? await browser.newContext() : browser.contexts()[0];
-        await applyInitScript(browserContext, this.config);
-        await hidePlaywrightMarkers(browserContext);
-        return browserContext;
-    }
-}
-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) {
-        const browserContext = await browser.newContext();
-        await applyInitScript(browserContext, this.config);
-        await hidePlaywrightMarkers(browserContext);
-        return browserContext;
-    }
-}
-class PersistentContextFactory {
-    config;
-    name = 'persistent';
-    description = 'Create a new persistent browser context';
-    _userDataDirs = new Set();
-    _autoCloseTimer;
-    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);
-        const tracesDir = await startTraceServer(this.config, clientInfo.rootPath);
-        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,
-                    args: this.config.browser.launchOptions?.args || [],
-                });
-                await applyInitScript(browserContext, this.config);
-                await hidePlaywrightMarkers(browserContext);
-                // Start auto-close timer
-                this._startAutoCloseTimer(browserContext);
-                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`);
-    }
-    _startAutoCloseTimer(browserContext) {
-        this._clearAutoCloseTimer();
-        testDebug(`schedule auto-close in ${TIMEOUT_STR} (persistent)`);
-        this._autoCloseTimer = setTimeout(async () => {
-            testDebug(`auto-closing browser after ${TIMEOUT_STR} (persistent)`);
-            try {
-                await browserContext.close();
-                testDebug(`auto-close complete (persistent)`);
-            }
-            catch (error) {
-                testDebug(`error during auto-close: ${error}`);
-            }
-        }, ms(TIMEOUT_STR));
-    }
-    _clearAutoCloseTimer() {
-        if (this._autoCloseTimer) {
-            testDebug(`cancel auto-close timer (persistent)`);
-            clearTimeout(this._autoCloseTimer);
-            this._autoCloseTimer = undefined;
-        }
-    }
-    async _closeBrowserContext(browserContext, userDataDir) {
-        testDebug('close browser context (persistent)');
-        testDebug('release user data dir', userDataDir);
-        this._clearAutoCloseTimer();
-        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) {
-    const isBunRuntime = 'bun' in process.versions;
-    if (isBunRuntime)
-        return;
-    if (browserConfig.browserName !== 'chromium')
-        return;
-    const launchOptions = browserConfig.launchOptions || {};
-    launchOptions.cdpPort = await findFreePort();
-    browserConfig.launchOptions = launchOptions;
-}
-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);
-    });
-}
-async function startTraceServer(config, rootPath) {
-    if (!config.saveTrace)
-        return undefined;
-    const tracesDir = await outputFile(config, rootPath, `traces-${Date.now()}`);
-    const server = await startTraceViewerServer();
-    const urlPrefix = server.urlPrefix('human-readable');
-    const url = urlPrefix + '/trace/index.html?trace=' + tracesDir + '/trace.json';
-    // eslint-disable-next-line no-console
-    console.error('\nTrace viewer listening on ' + url);
-    return tracesDir;
-}

package/lib/browserServerBackend.js

@@ -1,84 +0,0 @@
-/**
- * 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 { Context } from './context.js';
-import { logUnhandledError } from './utils/log.js';
-import { Response } from './response.js';
-import { SessionLog } from './sessionLog.js';
-import { filteredTools } from './tools.js';
-import { packageJSON } from './utils/package.js';
-import { toMcpTool } from './mcp/tool.js';
-export class BrowserServerBackend {
-    name = 'Playwright';
-    version = packageJSON.version;
-    _tools;
-    _context;
-    _sessionLog;
-    _config;
-    _browserContextFactory;
-    constructor(config, factory) {
-        this._config = config;
-        this._browserContextFactory = factory;
-        this._tools = filteredTools(config);
-    }
-    async initialize(server) {
-        const capabilities = server.getClientCapabilities();
-        let rootPath;
-        if (capabilities?.roots) {
-            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 },
-        });
-        if (this._config.browser.app)
-            await this._context.ensureTab();
-    }
-    async listTools() {
-        return this._tools.map(tool => toMcpTool(tool.schema));
-    }
-    async callTool(name, rawArguments) {
-        const context = this._context;
-        const tool = context.tools.find(tool => tool.schema.name === name);
-        if (!tool)
-            throw new Error(`Tool "${name}" not found`);
-        const parsedArguments = tool.schema.inputSchema.parse(rawArguments || {});
-        const response = new Response(context, name, parsedArguments);
-        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() {
-        void this._context?.dispose().catch(logUnhandledError);
-    }
-}

package/lib/config.js

@@ -1,286 +0,0 @@
-/**
- * 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-core';
-import { sanitizeForFilePath } from './utils/fileUtils.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;
-    // Add default Chrome args to avoid automation detection
-    launchOptions.args = launchOptions.args || [];
-    launchOptions.args.push('--disable-infobars');
-    // --app was passed, add app mode argument
-    if (cliOptions.app) {
-        launchOptions.args = launchOptions.args || [];
-        launchOptions.args.push(`--app=${cliOptions.app}`);
-    }
-    // --window-position was passed, add window position argument
-    if (cliOptions.windowPosition) {
-        try {
-            const [x, y] = cliOptions.windowPosition.split(',').map(n => +n);
-            if (isNaN(x) || isNaN(y))
-                throw new Error('bad values');
-            launchOptions.args = launchOptions.args || [];
-            launchOptions.args.push(`--window-position=${x},${y}`);
-        }
-        catch (e) {
-            throw new Error('Invalid window position format: use "x,y", for example --window-position="100,200"');
-        }
-    }
-    // --window-size was passed, add window size argument
-    if (cliOptions.windowSize) {
-        try {
-            const [width, height] = cliOptions.windowSize.split(',').map(n => +n);
-            if (isNaN(width) || isNaN(height))
-                throw new Error('bad values');
-            launchOptions.args = launchOptions.args || [];
-            launchOptions.args.push(`--window-size=${width},${height}`);
-        }
-        catch (e) {
-            throw new Error('Invalid window size format: use "width,height", for example --window-size="1280,720"');
-        }
-    }
-    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,
-            initScript: cliOptions.initScript,
-            app: cliOptions.app,
-        },
-        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,
-    };
-    return result;
-}
-function configFromEnv() {
-    const options = {};
-    options.allowedOrigins = semicolonSeparatedList(process.env.PLAYWRIGHT_MCP_ALLOWED_ORIGINS);
-    options.app = envToString(process.env.PLAYWRIGHT_MCP_APP);
-    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.initScript = envToString(process.env.PLAYWRIGHT_MCP_INIT_SCRIPT);
-    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.windowPosition = envToString(process.env.PLAYWRIGHT_MCP_WINDOW_POSITION);
-    options.windowSize = envToString(process.env.PLAYWRIGHT_MCP_WINDOW_SIZE);
-    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;
-}