@wordbricks/playwright-mcp 0.1.20 → 0.1.22

package/cli-wrapper.js

@@ -15,33 +15,34 @@
  * limitations under the License.
  */
 
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
+import { spawn } from "child_process";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-const isBunRuntime = 'bun' in process.versions;
-const isRunViaBundle = process.env.npm_execpath && process.env.npm_execpath.includes('bunx');
+const isBunRuntime = "bun" in process.versions;
+const isRunViaBundle =
+  process.env.npm_execpath && process.env.npm_execpath.includes("bunx");
 
 if (!isBunRuntime && isRunViaBundle) {
-  const cliPath = join(__dirname, 'cli.js');
+  const cliPath = join(__dirname, "cli.js");
   const args = process.argv.slice(2);
 
-  const bunProcess = spawn('bun', [cliPath, ...args], {
-    stdio: 'inherit',
-    env: { ...process.env, FORCE_BUN_RUNTIME: '1' }
+  const bunProcess = spawn("bun", [cliPath, ...args], {
+    stdio: "inherit",
+    env: { ...process.env, FORCE_BUN_RUNTIME: "1" },
   });
 
-  bunProcess.on('exit', (code) => {
+  bunProcess.on("exit", (code) => {
     process.exit(code || 0);
   });
 
-  bunProcess.on('error', (err) => {
-    console.error('Failed to run with bun:', err.message);
-    import('./lib/program.js');
+  bunProcess.on("error", (err) => {
+    console.error("Failed to run with bun:", err.message);
+    import("./lib/program.js");
   });
 } else {
-  import('./lib/program.js');
+  import("./lib/program.js");
 }

package/cli.js

@@ -15,4 +15,4 @@
  * limitations under the License.
  */
 
-import './lib/program.js';
+import "./lib/program.js";

package/config.d.ts

@@ -14,9 +14,14 @@
  * limitations under the License.
  */
 
-import type * as playwright from 'playwright-core';
+import type * as playwright from "playwright-core";
 
-export type ToolCapability = 'core' | 'core-tabs' | 'core-install' | 'vision' | 'pdf';
+export type ToolCapability =
+  | "core"
+  | "core-tabs"
+  | "core-install"
+  | "vision"
+  | "pdf";
 
 export type Config = {
   /**
@@ -26,7 +31,7 @@ export type Config = {
     /**
      * The type of browser to use.
      */
-    browserName?: 'chromium' | 'firefox' | 'webkit';
+    browserName?: "chromium" | "firefox" | "webkit";
 
     /**
      * Keep the browser profile in memory, do not save it to disk.
@@ -73,7 +78,7 @@ export type Config = {
      * URL to launch in Chrome app mode.
      */
     app?: string;
-  },
+  };
 
   server?: {
     /**
@@ -85,7 +90,7 @@ export type Config = {
      * The host to bind the server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.
      */
     host?: string;
-  },
+  };
 
   /**
    * List of enabled tool capabilities. Possible values:
@@ -125,5 +130,5 @@ export type Config = {
   /**
    * Whether to send image responses to the client. Can be "allow", "omit", or "auto". Defaults to "auto", which sends images if the client can display them.
    */
-  imageResponses?: 'allow' | 'omit';
+  imageResponses?: "allow" | "omit";
 };

package/index.d.ts

@@ -15,9 +15,11 @@
  * limitations under the License.
  */
 
-import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import type { Config } from './config.js';
-import type { BrowserContext } from 'playwright-core';
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import type { Config } from "./config.js";
+import type { BrowserContext } from "playwright-core";
 
-export declare function createConnection(config?: Config, contextGetter?: () => Promise<BrowserContext>): Promise<Server>;
-export {};
+export declare function createConnection(
+  config?: Config,
+  contextGetter?: () => Promise<BrowserContext>,
+): Promise<Server>;

package/index.js

@@ -15,5 +15,5 @@
  * limitations under the License.
  */
 
-import { createConnection } from './lib/index.js';
+import { createConnection } from "./lib/index.js";
 export { createConnection };

package/lib/browserContextFactory.js

@@ -13,22 +13,75 @@
  * 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';
+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');
+        const scriptContent = await fs.promises.readFile(config.browser.initScript, "utf8");
         await browserContext.addInitScript(scriptContent);
     }
 }
@@ -40,23 +93,23 @@ async function hidePlaywrightMarkers(browserContext) {
         const originalGetOwnPropertyNames = Object.getOwnPropertyNames;
         Object.getOwnPropertyNames = (obj) => {
             const props = originalGetOwnPropertyNames(obj);
-            return props.filter((prop) => prop !== '__pwInitScripts');
+            return props.filter((prop) => prop !== "__pwInitScripts");
         };
         // Use a Proxy to handle access to `window`
         const windowHandler = {
             get(target, prop) {
-                if (prop === '__pwInitScripts')
+                if (prop === "__pwInitScripts")
                     return undefined; // Hide the property
                 return Reflect.get(target, prop);
             },
             has(target, prop) {
-                if (prop === '__pwInitScripts')
+                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', {
+        Object.defineProperty(globalThis, "window", {
             value: proxiedWindow,
             configurable: false,
             writable: false,
@@ -88,14 +141,16 @@ class BaseContextFactory {
             return this._browserPromise;
         testDebug(`obtain browser (${this.name})`);
         this._browserPromise = this._doObtainBrowser(clientInfo);
-        void this._browserPromise.then(browser => {
-            browser.on('disconnected', () => {
+        void this._browserPromise
+            .then((browser) => {
+            browser.on("disconnected", () => {
                 this._browserPromise = undefined;
                 this._clearAutoCloseTimer();
             });
             // Start auto-close timer
             this._startAutoCloseTimer(browser);
-        }).catch(() => {
+        })
+            .catch(() => {
             this._browserPromise = undefined;
             this._clearAutoCloseTimer();
         });
@@ -124,16 +179,19 @@ class BaseContextFactory {
         }
     }
     async _doObtainBrowser(clientInfo) {
-        throw new Error('Not implemented');
+        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) };
+        return {
+            browserContext,
+            close: () => this._closeBrowserContext(browserContext, browser),
+        };
     }
     async _doCreateContext(browser) {
-        throw new Error('Not implemented');
+        throw new Error("Not implemented");
     }
     async _closeBrowserContext(browserContext, browser) {
         testDebug(`close browser context (${this.name})`);
@@ -151,25 +209,29 @@ class BaseContextFactory {
 }
 class IsolatedContextFactory extends BaseContextFactory {
     constructor(config) {
-        super('isolated', 'Create a new isolated browser context', 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({
+        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'))
+        })
+            .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);
+        const browserContext = await browser.newContext({
+            ...this.config.browser.contextOptions,
+            bypassCSP: true,
+        });
         await applyInitScript(browserContext, this.config);
         await hidePlaywrightMarkers(browserContext);
         return browserContext;
@@ -177,13 +239,15 @@ class IsolatedContextFactory extends BaseContextFactory {
 }
 class CdpContextFactory extends BaseContextFactory {
     constructor(config) {
-        super('cdp', 'Connect to a browser over CDP', 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];
+        const browserContext = this.config.browser.isolated
+            ? await browser.newContext({ bypassCSP: true })
+            : browser.contexts()[0];
         await applyInitScript(browserContext, this.config);
         await hidePlaywrightMarkers(browserContext);
         return browserContext;
@@ -191,17 +255,17 @@ class CdpContextFactory extends BaseContextFactory {
 }
 class RemoteContextFactory extends BaseContextFactory {
     constructor(config) {
-        super('remote', 'Connect to a browser using a remote endpoint', 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);
+        url.searchParams.set("browser", this.config.browser.browserName);
         if (this.config.browser.launchOptions)
-            url.searchParams.set('launch-options', JSON.stringify(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();
+        const browserContext = await browser.newContext({ bypassCSP: true });
         await applyInitScript(browserContext, this.config);
         await hidePlaywrightMarkers(browserContext);
         return browserContext;
@@ -209,8 +273,8 @@ class RemoteContextFactory extends BaseContextFactory {
 }
 class PersistentContextFactory {
     config;
-    name = 'persistent';
-    description = 'Create a new persistent browser context';
+    name = "persistent";
+    description = "Create a new persistent browser context";
     _userDataDirs = new Set();
     _autoCloseTimer;
     constructor(config) {
@@ -218,11 +282,14 @@ class PersistentContextFactory {
     }
     async createContext(clientInfo) {
         await injectCdpPort(this.config.browser);
-        testDebug('create browser context (persistent)');
-        const userDataDir = this.config.browser.userDataDir ?? await this._createUserDataDir(clientInfo.rootPath);
+        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);
+        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 {
@@ -230,9 +297,9 @@ class PersistentContextFactory {
                     tracesDir,
                     ...this.config.browser.launchOptions,
                     ...this.config.browser.contextOptions,
+                    bypassCSP: true,
                     handleSIGINT: false,
                     handleSIGTERM: false,
-                    args: this.config.browser.launchOptions?.args || [],
                 });
                 await applyInitScript(browserContext, this.config);
                 await hidePlaywrightMarkers(browserContext);
@@ -242,11 +309,12 @@ class PersistentContextFactory {
                 return { browserContext, close };
             }
             catch (error) {
-                if (error.message.includes('Executable doesn\'t exist'))
+                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')) {
+                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));
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
                     continue;
                 }
                 throw error;
@@ -276,31 +344,36 @@ class PersistentContextFactory {
         }
     }
     async _closeBrowserContext(browserContext, userDataDir) {
-        testDebug('close browser context (persistent)');
-        testDebug('release user data dir', 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)');
+        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;
+        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 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)
+    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')
+    if (browserConfig.browserName !== "chromium")
         return;
     const launchOptions = browserConfig.launchOptions || {};
-    launchOptions.cdpPort = await findFreePort();
+    const cdpPort = await findFreePort();
+    launchOptions.cdpPort = cdpPort;
     browserConfig.launchOptions = launchOptions;
 }
 async function findFreePort() {
@@ -310,7 +383,7 @@ async function findFreePort() {
             const { port } = server.address();
             server.close(() => resolve(port));
         });
-        server.on('error', reject);
+        server.on("error", reject);
     });
 }
 async function startTraceServer(config, rootPath) {
@@ -318,9 +391,9 @@ async function startTraceServer(config, rootPath) {
         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';
+    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);
+    console.error("\nTrace viewer listening on " + url);
     return tracesDir;
 }

package/lib/browserServerBackend.js

@@ -13,16 +13,16 @@
  * 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';
+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';
+    name = "Playwright";
     version = packageJSON.version;
     _tools;
     _context;
@@ -43,7 +43,9 @@ export class BrowserServerBackend {
             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._sessionLog = this._config.saveSession
+            ? await SessionLog.create(this._config, rootPath)
+            : undefined;
         this._context = new Context({
             tools: this._tools,
             config: this._config,
@@ -55,11 +57,11 @@ export class BrowserServerBackend {
             await this._context.ensureTab();
     }
     async listTools() {
-        return this._tools.map(tool => toMcpTool(tool.schema));
+        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);
+        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 || {});