@wordbricks/playwright-mcp 0.1.25 → 0.1.26

package/lib/browserContextFactory.js

@@ -0,0 +1,399 @@
+/**
+ * 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 "node:fs";
+import net from "node:net";
+import path from "node:path";
+import ms from "ms";
+import * as playwright from "playwright-core";
+// @ts-expect-error
+import { startTraceViewerServer } from "playwright-core/lib/server";
+// @ts-expect-error
+import { registryDirectory } from "playwright-core/lib/server/registry/index";
+import { outputFile } from "./config.js";
+import { createHash } from "./utils/guid.js";
+import { logUnhandledError, testDebug } from "./utils/log.js";
+const TIMEOUT_STR = "30m";
+// Disable password manager in Chrome Preferences file
+async function disablePasswordManagerInPrefs(userDataDir) {
+    const prefsPath = path.join(userDataDir, "Default", "Preferences");
+    const defaultDir = path.join(userDataDir, "Default");
+    // Ensure Default directory exists
+    await fs.promises.mkdir(defaultDir, { recursive: true });
+    let prefs = {};
+    try {
+        const existing = await fs.promises.readFile(prefsPath, "utf8");
+        prefs = JSON.parse(existing);
+    }
+    catch {
+        // File doesn't exist or is invalid, start fresh
+    }
+    // Disable password manager settings
+    prefs.credentials_enable_service = false;
+    prefs.credentials_enable_autosignin = false;
+    prefs.password_manager_enabled = false;
+    // Nested profile preferences
+    prefs.profile = prefs.profile || {};
+    prefs.profile.password_manager_enabled = false;
+    // Password manager specific settings
+    prefs.password_manager =
+        prefs.password_manager || {};
+    prefs.password_manager.saving_enabled = false;
+    prefs.password_manager.autofilling_enabled =
+        false;
+    await fs.promises.writeFile(prefsPath, JSON.stringify(prefs, null, 2));
+}
+async function applyInitScript(browserContext, config) {
+    // Clear stale auth mode from previous sessions on first page load
+    // Uses a session marker to avoid clearing during active auth navigation
+    const sessionId = Date.now().toString();
+    await browserContext.addInitScript((sid) => {
+        try {
+            const currentSession = sessionStorage.getItem("__nr_session__");
+            const authMode = localStorage.getItem("__nr_auth_mode__");
+            console.log("[NextRows:Init] Session check", {
+                currentSession,
+                newSessionId: sid,
+                authModeBefore: authMode,
+            });
+            if (currentSession !== sid) {
+                // New session - clear any stale auth state
+                localStorage.removeItem("__nr_auth_mode__");
+                localStorage.removeItem("__nr_auth_continue__");
+                sessionStorage.setItem("__nr_session__", sid);
+                console.log("[NextRows:Init] Cleared stale auth state for new session");
+            }
+        }
+        catch (e) {
+            console.log("[NextRows:Init] Error in session check", e);
+        }
+    }, sessionId);
+    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,
+        })
+            .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,
+            bypassCSP: true,
+        });
+        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({ bypassCSP: true })
+            : 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({ bypassCSP: true });
+        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);
+        // Disable password manager in Chrome preferences before launch
+        await disablePasswordManagerInPrefs(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,
+                    bypassCSP: true,
+                    handleSIGINT: false,
+                    handleSIGTERM: false,
+                });
+                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;
+    const isWindows = process.platform === "win32";
+    // On Windows, always use CDP port because Bun has issues with --remote-debugging-pipe
+    // On other platforms, Bun handles pipes correctly
+    if (!isWindows && isBunRuntime)
+        return;
+    if (browserConfig.browserName !== "chromium")
+        return;
+    const launchOptions = browserConfig.launchOptions || {};
+    const cdpPort = await findFreePort();
+    launchOptions.cdpPort = cdpPort;
+    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

@@ -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);
+    }
+}