@wordbricks/playwright-mcp 0.1.26 → 0.1.30

package/lib/browserContextFactory.js

@@ -109,11 +109,16 @@ async function hidePlaywrightMarkers(browserContext) {
             },
         };
         const proxiedWindow = new Proxy(window, windowHandler);
-        Object.defineProperty(globalThis, "window", {
-            value: proxiedWindow,
-            configurable: false,
-            writable: false,
-        });
+        try {
+            Object.defineProperty(globalThis, "window", {
+                value: proxiedWindow,
+                configurable: true,
+                writable: false,
+            });
+        }
+        catch {
+            // Ignore if window property is already non-configurable
+        }
     });
 }
 export function contextFactory(config) {
@@ -232,6 +237,10 @@ class IsolatedContextFactory extends BaseContextFactory {
             ...this.config.browser.contextOptions,
             bypassCSP: true,
         });
+        // Grant local-network-access permission to suppress LNA prompt (Chrome 142+)
+        await browserContext
+            .grantPermissions(["local-network-access"])
+            .catch(() => { });
         await applyInitScript(browserContext, this.config);
         await hidePlaywrightMarkers(browserContext);
         return browserContext;
@@ -248,6 +257,10 @@ class CdpContextFactory extends BaseContextFactory {
         const browserContext = this.config.browser.isolated
             ? await browser.newContext({ bypassCSP: true })
             : browser.contexts()[0];
+        // Grant local-network-access permission to suppress LNA prompt (Chrome 142+)
+        await browserContext
+            .grantPermissions(["local-network-access"])
+            .catch(() => { });
         await applyInitScript(browserContext, this.config);
         await hidePlaywrightMarkers(browserContext);
         return browserContext;
@@ -288,6 +301,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 +328,48 @@ 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];
+                // Grant local-network-access permission to suppress LNA prompt (Chrome 142+)
+                await browserContext
+                    .grantPermissions(["local-network-access"])
+                    .catch(() => { });
                 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 +378,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 +490,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 +599,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,LocalNetworkAccessCheck", "--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/lib/program.js

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 import { Option, program } from "commander";
+import dotenv from "dotenv";
+import fs from "fs";
 import { contextFactory } from "./browserContextFactory.js";
 import { BrowserServerBackend } from "./browserServerBackend.js";
 import { commaSeparatedList, resolveCLIConfig, semicolonSeparatedList, } from "./config.js";
@@ -24,6 +26,22 @@ import { ProxyBackend } from "./mcp/proxyBackend.js";
 import * as mcpServer from "./mcp/server.js";
 import * as mcpTransport from "./mcp/transport.js";
 import { packageJSON } from "./utils/package.js";
+export function dotenvFileLoader(value) {
+    if (!value)
+        return undefined;
+    if (!fs.existsSync(value))
+        return undefined;
+    return dotenv.parse(fs.readFileSync(value, "utf8"));
+}
+function loadSecretsFromCli(options) {
+    const secrets = dotenvFileLoader(options.secret);
+    if (!secrets)
+        return;
+    for (const [key, value] of Object.entries(secrets)) {
+        if (process.env[key] === undefined)
+            process.env[key] = value;
+    }
+}
 program
     .version("Version " + packageJSON.version)
     .name(packageJSON.name)
@@ -52,6 +70,7 @@ program
     .option("--storage-state <path>", "path to the storage state file for isolated sessions.")
     .option("--user-agent <ua string>", "specify user agent string")
     .option("--user-data-dir <path>", "path to the user data directory. If not specified, a temporary directory will be created.")
+    .option("--secret <path>", "path to a file containing secrets in the dotenv format")
     .option("--viewport-size <size>", 'specify browser viewport size in pixels, for example "1280, 720"')
     .option("--window-position <x,y>", 'specify Chrome window position in pixels, for example "100,200"')
     .option("--window-size <width,height>", 'specify Chrome window size in pixels, for example "1280,720"')
@@ -62,6 +81,7 @@ program
     .addOption(new Option("--vision", "Legacy option, use --caps=vision instead").hideHelp())
     .action(async (options) => {
     setupExitWatchdog();
+    loadSecretsFromCli(options);
     if (options.vision) {
         // eslint-disable-next-line no-console
         console.error("The --vision option is deprecated, use --caps=vision instead");

package/lib/response.js

@@ -21,6 +21,7 @@ export class Response {
     _events = [];
     _code = [];
     _images = [];
+    _screenshotUrl = null;
     _context;
     _includeSnapshot = false;
     _includeTabs = false;
@@ -62,6 +63,9 @@ export class Response {
     images() {
         return this._images;
     }
+    addScreenshotUrl(url) {
+        this._screenshotUrl = url;
+    }
     // NOTE Wordbricks Disabled: Page state logging not needed
     setIncludeSnapshot(full) {
         // this._includeSnapshot = full ?? 'incremental';
@@ -125,7 +129,13 @@ ${this._code.join("\n")}
         }
         // Main response part
         const content = [
-            { type: "text", text: response.join("\n") },
+            {
+                type: "text",
+                text: response.join("\n"),
+                ...(this._screenshotUrl && {
+                    _meta: { screenShotUrl: this._screenshotUrl },
+                }),
+            },
         ];
         // Image attachments.
         if (this._context.config.imageResponses !== "omit") {

package/lib/tools/getSnapshot.js

@@ -22,7 +22,7 @@ const getSnapshot = defineTool({
             lines.push(`- Page Title: ${snapshot.title}`);
             lines.push(`- Page Snapshot:`);
             lines.push("```yaml");
-            let aria = snapshot.ariaSnapshot || "";
+            let aria = JSON.stringify(snapshot.ariaSnapshot) || ""; // HOTFIX: JSON.stringify is hotfix, Find root cause
             aria = String(truncate(aria, { maxStringLength: MAX_LENGTH }));
             lines.push(aria);
             lines.push("```");

package/lib/tools/navigate.js

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import { z } from "zod";
+import { captureAndUploadScreenshot } from "../utils/screenshot.js";
 import { defineTabTool, defineTool } from "./tool.js";
 const navigate = defineTool({
     capability: "core",
@@ -29,6 +30,10 @@ const navigate = defineTool({
     handle: async (context, params, response) => {
         const tab = await context.ensureTab();
         await tab.navigate(params.url);
+        const screenshotUrl = await captureAndUploadScreenshot(tab.page);
+        if (screenshotUrl) {
+            response.addScreenshotUrl(screenshotUrl);
+        }
         response.setIncludeSnapshot();
         response.addCode(`await page.goto('${params.url}');`);
     },

package/lib/tools/scroll.js

@@ -1,5 +1,6 @@
 import ms from "ms";
 import { z } from "zod";
+import { captureAndUploadScreenshot } from "../utils/screenshot.js";
 import { defineTabTool } from "./tool.js";
 /**
  * Generate random number between min and max
@@ -126,6 +127,10 @@ const scrollWheel = defineTabTool({
         }));
         // Always show scroll position for scroll tool
         response.addResult(`Scroll position:\nBefore: x=${initialScrollPosition.x}, y=${initialScrollPosition.y}\nAfter: x=${finalScrollPosition.x}, y=${finalScrollPosition.y}`);
+        const screenshotUrl = await captureAndUploadScreenshot(tab.page);
+        if (screenshotUrl) {
+            response.addScreenshotUrl(screenshotUrl);
+        }
     },
 });
 export default [scrollWheel];

package/lib/tools/snapshot.js

@@ -15,6 +15,7 @@
  */
 import { z } from "zod";
 import * as javascript from "../utils/codegen.js";
+import { captureAndUploadScreenshot } from "../utils/screenshot.js";
 import { defineTabTool, defineTool } from "./tool.js";
 import { generateLocator } from "./utils.js";
 const snapshot = defineTool({
@@ -81,6 +82,10 @@ const click = defineTabTool({
             else
                 await locator.click(options);
         });
+        const screenshotUrl = await captureAndUploadScreenshot(tab.page);
+        if (screenshotUrl) {
+            response.addScreenshotUrl(screenshotUrl);
+        }
     },
 });
 const drag = defineTabTool({

package/lib/utils/screenshot.js

@@ -0,0 +1,43 @@
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { createGuid } from "./guid.js";
+const S3_REGION = "us-west-1";
+const ENABLE_SCREENSHOT_VALUES = new Set(["1", "true", "yes", "on"]);
+export const isScreenshotEnabled = () => ENABLE_SCREENSHOT_VALUES.has((process.env.ENABLE_SCREENSHOT_ON_NAVIGATE ?? "").toLowerCase());
+/**
+ * Captures a screenshot, uploads it to S3, and returns the URL.
+ * Waits 1 second before taking the screenshot to let the page settle.
+ */
+export async function captureAndUploadScreenshot(page) {
+    if (!isScreenshotEnabled())
+        return null;
+    const bucket = process.env.SCREENSHOT_S3_BUCKET;
+    const AWS_ACCESS_KEY_ID = process.env.AWS_ACCESS_KEY_ID;
+    const AWS_SECRET_ACCESS_KEY = process.env.AWS_SECRET_ACCESS_KEY;
+    const hasCredentials = Boolean(AWS_ACCESS_KEY_ID) && Boolean(AWS_SECRET_ACCESS_KEY);
+    if (!bucket || !hasCredentials)
+        return null;
+    await page.waitForLoadState("networkidle");
+    const s3Client = new S3Client({ region: S3_REGION });
+    const screenshotUrl = await page
+        .screenshot({
+        type: "jpeg",
+        quality: 80,
+        scale: "css",
+        timeout: 10000,
+    })
+        .then(async (screenshot) => {
+        const objectKey = `playwright-mcp/screenshot/${createGuid()}.jpg`;
+        await s3Client.send(new PutObjectCommand({
+            Bucket: bucket,
+            Key: objectKey,
+            Body: screenshot,
+            ContentType: "image/jpeg",
+        }));
+        return `https://${bucket}.s3.${S3_REGION}.amazonaws.com/${objectKey}`;
+    })
+        .catch((error) => {
+        console.error("Failed to capture and upload screenshot", error);
+        return null;
+    });
+    return screenshotUrl;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wordbricks/playwright-mcp",
-  "version": "0.1.26",
+  "version": "0.1.30",
   "description": "Playwright Tools for MCP",
   "type": "module",
   "files": [
@@ -18,11 +18,11 @@
     "build": "tsc && bun run copy-filters",
     "copy-filters": "mkdir -p lib/filters && cp -r src/filters/*.txt lib/filters/ 2>/dev/null || true",
     "build:extension": "tsc --project extension",
-    "dev": "concurrently --raw prefix none \"tsc --watch\" \"DEBUG=pw:mcp:* node --watch=lib cli.js --port 9224 --isolated\"",
-    "dev:headless": "concurrently --raw prefix none \"tsc --watch\" \"DEBUG=pw:mcp:* node --watch=lib cli.js --port 9224 --isolated --headless\"",
-    "start": "node cli.js --port 9224",
-    "start:isolated": "node cli.js --port 9224 --isolated",
-    "start:vision": "node cli.js --port 9224 --caps=vision",
+    "dev": "concurrently --raw prefix none \"tsc --watch\" \"DEBUG=pw:mcp:* node --watch=lib cli.js --port 9224 --isolated --secret .env.development\"",
+    "dev:headless": "concurrently --raw prefix none \"tsc --watch\" \"DEBUG=pw:mcp:* node --watch=lib cli.js --port 9224 --isolated --headless --secret .env.development\"",
+    "start": "node cli.js --port 9224 --secret .env.production",
+    "start:isolated": "node cli.js --port 9224 --isolated --secret .env.production",
+    "start:vision": "node cli.js --port 9224 --caps=vision --secret .env.production",
     "lint": "biome check --diagnostic-level=error",
     "format": "biome check --write --diagnostic-level=error",
     "check-types": "tsc --noEmit",
@@ -46,9 +46,10 @@
     "./cli.js": "./cli.js"
   },
   "dependencies": {
-    "@fxts/core": "1.21.1",
-    "@ghostery/adblocker": "2.13.0",
-    "@modelcontextprotocol/sdk": "1.24.3",
+    "@fxts/core": "1.23.0",
+    "@ghostery/adblocker": "2.13.2",
+    "@aws-sdk/client-s3": "3.958.0",
+    "@modelcontextprotocol/sdk": "1.25.1",
     "cheerio": "1.1.2",
     "commander": "14.0.2",
     "content-type": "1.0.5",
@@ -60,7 +61,7 @@
     "lodash": "4.17.21",
     "mime": "4.1.0",
     "ms": "2.1.3",
-    "playwright-core": "1.56.1",
+    "playwright-core": "1.57.0",
     "raw-body": "3.0.2",
     "typescript-parsec": "0.3.4",
     "ws": "8.18.3",
@@ -75,15 +76,15 @@
     "@types/content-type": "1.1.9",
     "@types/debug": "4.1.12",
     "@types/ms": "2.1.0",
-    "@types/bun": "1.3.4",
-    "@types/node": "24.10.1",
+    "@types/bun": "1.3.5",
+    "@types/node": "25.0.3",
     "@types/ws": "8.18.1",
     "concurrently": "9.2.1",
     "domelementtype": "2.3.0",
     "domhandler": "5.0.3",
-    "devtools-protocol": "0.0.1558402",
-    "esbuild": "0.27.1",
-    "openai": "6.10.0",
+    "devtools-protocol": "0.0.1561482",
+    "esbuild": "0.27.2",
+    "openai": "6.15.0",
     "typescript": "5.9.3"
   },
   "bin": {