@wordbricks/playwright-mcp 0.1.25 → 0.1.27

package/lib/browserContextFactory.js

@@ -0,0 +1,616 @@
+/**
+ * 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);
+        // Try to connect to an existing browser via CDP first
+        // This enables concurrent chats to share the same browser instance
+        const cdpResult = await this._tryConnectViaCDP(userDataDir);
+        if (cdpResult) {
+            testDebug("connected to existing browser via CDP");
+            const { browserContext, initialPage } = cdpResult;
+            await applyInitScript(browserContext, this.config);
+            await hidePlaywrightMarkers(browserContext);
+            // Increment ref count for this CDP connection
+            await this._incrementRefCount(userDataDir);
+            // Close only this chat's page, not the entire shared context
+            const close = () => this._closeCdpContext(initialPage, userDataDir);
+            return { browserContext, close, initialPage };
+        }
+        // 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,
+                });
+                // Write CDP port to file for other instances to connect
+                const cdpPort = this.config.browser.launchOptions?.cdpPort;
+                if (cdpPort) {
+                    const cdpEndpointFile = path.join(userDataDir, "PlaywrightCdpPort");
+                    await fs.promises.writeFile(cdpEndpointFile, String(cdpPort), "utf8");
+                }
+                // Get the initial page (persistent context creates one automatically)
+                const initialPage = browserContext.pages()[0];
+                await applyInitScript(browserContext, this.config);
+                await hidePlaywrightMarkers(browserContext);
+                // Increment ref count for this persistent context
+                await this._incrementRefCount(userDataDir);
+                // Start auto-close timer
+                this._startAutoCloseTimer(browserContext);
+                // Only close the initial page, not the entire context
+                // This allows other chats to continue using the shared browser
+                const close = () => this._closePersistentPage(initialPage, browserContext, userDataDir);
+                return { browserContext, close, initialPage };
+            }
+            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 CDP connection
+                    testDebug("browser in use, trying CDP connection...");
+                    const cdpRetry = await this._tryConnectViaCDP(userDataDir);
+                    if (cdpRetry) {
+                        testDebug("connected to existing browser via CDP (retry)");
+                        const { browserContext, initialPage } = cdpRetry;
+                        await applyInitScript(browserContext, this.config);
+                        await hidePlaywrightMarkers(browserContext);
+                        // Increment ref count for this CDP connection
+                        await this._incrementRefCount(userDataDir);
+                        // Close only this chat's page, not the entire shared context
+                        const close = () => this._closeCdpContext(initialPage, userDataDir);
+                        return { browserContext, close, initialPage };
+                    }
+                    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`);
+    }
+    /**
+     * Try to connect to an existing browser via CDP.
+     * First tries PlaywrightCdpPort (written by our code), then falls back to DevToolsActivePort.
+     */
+    async _tryConnectViaCDP(userDataDir) {
+        const playwrightPortFile = path.join(userDataDir, "PlaywrightCdpPort");
+        const devToolsPortFile = path.join(userDataDir, "DevToolsActivePort");
+        try {
+            let port = null;
+            // Try PlaywrightCdpPort first (written by our code)
+            try {
+                const content = await fs.promises.readFile(playwrightPortFile, "utf8");
+                port = Number.parseInt(content.trim(), 10);
+            }
+            catch {
+                // Fall back to DevToolsActivePort (written by Chrome)
+                const content = await fs.promises.readFile(devToolsPortFile, "utf8");
+                const lines = content.trim().split("\n");
+                port = Number.parseInt(lines[0], 10);
+            }
+            if (!port || Number.isNaN(port)) {
+                testDebug("invalid port in CDP port file");
+                return null;
+            }
+            testDebug(`attempting CDP connection on port ${port}`);
+            const cdpEndpoint = `http://127.0.0.1:${port}`;
+            // Try to connect with a short timeout
+            const browser = await Promise.race([
+                playwright.chromium.connectOverCDP(cdpEndpoint),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("CDP connection timeout")), 3000)),
+            ]);
+            // Reuse existing context to share login sessions
+            const existingContexts = browser.contexts();
+            const browserContext = existingContexts.length > 0
+                ? existingContexts[0]
+                : await browser.newContext({
+                    ...this.config.browser.contextOptions,
+                    bypassCSP: true,
+                });
+            // Get window size and position from launch args for the popup
+            const args = this.config.browser.launchOptions?.args || [];
+            const sizeArg = args.find((arg) => arg.startsWith("--window-size="));
+            const posArg = args.find((arg) => arg.startsWith("--window-position="));
+            const appArg = args.find((arg) => arg.startsWith("--app="));
+            const [width, height] = sizeArg
+                ? sizeArg.replace("--window-size=", "").split(",").map(Number)
+                : [600, 1070];
+            const [left, top] = posArg
+                ? posArg.replace("--window-position=", "").split(",").map(Number)
+                : [1200, 40];
+            const appUrl = appArg ? appArg.replace("--app=", "") : "about:blank";
+            // Use window.open with popup features to create an app-like window (no address bar)
+            const existingPage = browserContext.pages()[0];
+            let newPage;
+            if (existingPage) {
+                const popupFeatures = `popup=true,width=${width},height=${height},left=${left},top=${top}`;
+                // Create popup and wait for the new page
+                const [popupPage] = await Promise.all([
+                    browserContext.waitForEvent("page", { timeout: 5000 }),
+                    existingPage.evaluate(([url, features]) => window.open(url, "_blank", features), [appUrl, popupFeatures]),
+                ]);
+                newPage = popupPage;
+            }
+            return { browser, browserContext, initialPage: newPage };
+        }
+        catch (error) {
+            testDebug(`CDP connection failed: ${error}`);
+            return null;
+        }
+    }
+    async _closeCdpContext(page, userDataDir) {
+        testDebug("close CDP page");
+        // Only close the specific page belonging to this chat, not the entire context
+        // Other chats may still be using the shared browserContext
+        if (page && !page.isClosed()) {
+            await page.close().catch(logUnhandledError);
+        }
+        // Decrement reference count
+        const remainingRefs = await this._decrementRefCount(userDataDir);
+        testDebug("remaining refs after CDP close:", remainingRefs);
+        // Note: We don't close the browser from CDP connections - the original
+        // persistent context owner (Chat A) or auto-close timer will handle that
+    }
+    _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 _closePersistentPage(page, browserContext, userDataDir) {
+        testDebug("close persistent page");
+        // Decrement reference count first to check if others are using the browser
+        const remainingRefs = await this._decrementRefCount(userDataDir);
+        testDebug("remaining refs after close:", remainingRefs);
+        if (remainingRefs <= 0) {
+            // No other processes using the browser, safe to close everything
+            testDebug("no refs left, closing browser context");
+            this._clearAutoCloseTimer();
+            await browserContext.close().catch(() => { });
+            this._userDataDirs.delete(userDataDir);
+        }
+        else {
+            // Other processes are still using the browser
+            // Don't close the page - just navigate to blank to "release" it
+            // Closing the page would close popup windows opened from it (window.open behavior)
+            testDebug("other refs exist, navigating to blank instead of closing page");
+            if (page && !page.isClosed()) {
+                await page.goto("about:blank").catch(() => { });
+            }
+        }
+    }
+    /**
+     * Increment the reference count for a shared browser userDataDir.
+     * Each MCP process using the browser increments this count.
+     */
+    async _incrementRefCount(userDataDir) {
+        const refCountFile = path.join(userDataDir, "PlaywrightRefCount");
+        const lockFile = path.join(userDataDir, "PlaywrightRefCount.lock");
+        // Simple file-based locking
+        for (let i = 0; i < 50; i++) {
+            try {
+                await fs.promises.writeFile(lockFile, String(process.pid), {
+                    flag: "wx",
+                });
+                break;
+            }
+            catch {
+                await new Promise((resolve) => setTimeout(resolve, 100));
+            }
+        }
+        try {
+            let count = 0;
+            try {
+                const content = await fs.promises.readFile(refCountFile, "utf8");
+                count = Number.parseInt(content, 10) || 0;
+            }
+            catch {
+                // File doesn't exist, start at 0
+            }
+            count++;
+            await fs.promises.writeFile(refCountFile, String(count), "utf8");
+            testDebug("incremented ref count to:", count);
+            return count;
+        }
+        finally {
+            await fs.promises.unlink(lockFile).catch(() => { });
+        }
+    }
+    /**
+     * Decrement the reference count for a shared browser userDataDir.
+     * Returns the new count after decrementing.
+     */
+    async _decrementRefCount(userDataDir) {
+        const refCountFile = path.join(userDataDir, "PlaywrightRefCount");
+        const lockFile = path.join(userDataDir, "PlaywrightRefCount.lock");
+        // Simple file-based locking
+        for (let i = 0; i < 50; i++) {
+            try {
+                await fs.promises.writeFile(lockFile, String(process.pid), {
+                    flag: "wx",
+                });
+                break;
+            }
+            catch {
+                await new Promise((resolve) => setTimeout(resolve, 100));
+            }
+        }
+        try {
+            let count = 0;
+            try {
+                const content = await fs.promises.readFile(refCountFile, "utf8");
+                count = Number.parseInt(content, 10) || 0;
+            }
+            catch {
+                // File doesn't exist
+                return 0;
+            }
+            count = Math.max(0, count - 1);
+            await fs.promises.writeFile(refCountFile, String(count), "utf8");
+            testDebug("decremented ref count to:", count);
+            return count;
+        }
+        finally {
+            await fs.promises.unlink(lockFile).catch(() => { });
+        }
+    }
+    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) {
+    // Always use CDP port for Chromium to enable concurrent browser access.
+    // When using a shared user data directory, subsequent instances need to
+    // connect via CDP to the existing browser instead of launching a new one.
+    // Chrome writes the assigned port to DevToolsActivePort file.
+    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;
+}