@wordbricks/playwright-mcp 0.1.26 → 0.1.27

package/lib/browserContextFactory.js

@@ -288,6 +288,20 @@ class PersistentContextFactory {
         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];
@@ -301,19 +315,44 @@ class PersistentContextFactory {
                     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);
-                const close = () => this._closeBrowserContext(browserContext, userDataDir);
-                return { browserContext, close };
+                // 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 again.
+                    // 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;
                 }
@@ -322,6 +361,89 @@ class PersistentContextFactory {
         }
         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)`);
@@ -351,6 +473,103 @@ class PersistentContextFactory {
         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 ??
@@ -363,12 +582,10 @@ class PersistentContextFactory {
     }
 }
 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;
+    // 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 || {};

package/lib/config.js

@@ -93,8 +93,10 @@ export function configFromCLIOptions(cliOptions) {
     "--hide-crash-restore-bubble", 
     // First run & default browser
     "--no-first-run", "--no-default-browser-check", 
-    // Disable various Chrome features (Translate, PasswordManager, Autofill, Sync)
-    "--disable-features=Translate,PasswordManager,PasswordManagerEnabled,PasswordManagerOnboarding,AutofillServerCommunication,CredentialManagerOnboarding", "--disable-sync", 
+    // 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

package/lib/context.js

@@ -234,13 +234,22 @@ export class Context {
             throw new Error("Another browser context is being closed.");
         // TODO: move to the browser context factory to make it based on isolation mode.
         const result = await this._browserContextFactory.createContext(this._clientInfo, this._abortController.signal);
-        const { browserContext } = result;
+        const { browserContext, initialPage } = result;
         await this._setupRequestInterception(browserContext);
         if (this.sessionLog)
             await InputRecorder.create(this, browserContext);
         for (const page of browserContext.pages())
             this._onPageCreated(page);
         browserContext.on("page", (page) => this._onPageCreated(page));
+        // If an initialPage was provided (e.g., from CDP connection), set it as the current tab
+        // This ensures each chat controls its own browser window, not someone else's
+        if (initialPage) {
+            const tab = this._tabs.find((t) => t.page === initialPage);
+            if (tab) {
+                this._currentTab = tab;
+                await initialPage.bringToFront();
+            }
+        }
         if (this.config.saveTrace) {
             await browserContext.tracing.start({
                 name: "trace",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wordbricks/playwright-mcp",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "Playwright Tools for MCP",
   "type": "module",
   "files": [