@wordbricks/playwright-mcp 0.1.25 → 0.1.27

package/lib/browserServerBackend.js

@@ -0,0 +1,86 @@
+/**
+ * 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 { toMcpTool } from "./mcp/tool.js";
+import { Response } from "./response.js";
+import { SessionLog } from "./sessionLog.js";
+import { filteredTools } from "./tools.js";
+import { logUnhandledError } from "./utils/log.js";
+import { packageJSON } from "./utils/package.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

@@ -0,0 +1,302 @@
+/**
+ * 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,
+        // Ignore default automation flag to reduce bot detection
+        ignoreDefaultArgs: ["--enable-automation"],
+    };
+    // --no-sandbox was passed, disable the sandbox
+    if (cliOptions.sandbox === false)
+        launchOptions.chromiumSandbox = false;
+    // Add default Chrome args to avoid automation detection and suppress popups
+    launchOptions.args = launchOptions.args || [];
+    launchOptions.args.push("--disable-infobars", 
+    // Password & credential popups
+    "--disable-save-password-bubble", "--password-store=basic", "--use-mock-keychain", 
+    // Crash restore popup
+    "--hide-crash-restore-bubble", 
+    // First run & default browser
+    "--no-first-run", "--no-default-browser-check", 
+    // Disable Cast/Media Router and local network discovery
+    "--media-router=0", "--disable-cast", "--disable-cast-streaming-hw-encoding", 
+    // Disable various Chrome features (Translate, PasswordManager, Autofill, Sync, MediaRouter, Cast)
+    "--disable-features=Translate,PasswordManager,PasswordManagerEnabled,PasswordManagerOnboarding,AutofillServerCommunication,CredentialManagerOnboarding,MediaRouter,GlobalMediaControls,CastMediaRouteProvider,DialMediaRouteProvider,CastAllowAllIPs,EnableCastDiscovery,LocalNetworkAccessChecks", "--disable-sync", 
+    // Disable password manager via experimental options
+    "--enable-features=DisablePasswordManager");
+    // --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;
+}