@wingman-ai/gateway 0.3.0 → 0.3.2

package/dist/agent/tests/browserControlTool.test.cjs

@@ -0,0 +1,2117 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const external_vitest_namespaceObject = require("vitest");
+const browser_control_cjs_namespaceObject = require("../tools/browser_control.cjs");
+(0, external_vitest_namespaceObject.describe)("browser_control tool", ()=>{
+    const workspaces = [];
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        for (const workspace of workspaces)(0, external_node_fs_namespaceObject.rmSync)(workspace, {
+            recursive: true,
+            force: true
+        });
+        workspaces.length = 0;
+    });
+    (0, external_vitest_namespaceObject.it)("runs browser actions through injected CDP/playwright dependencies", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let currentUrl = "about:blank";
+        let browserClosed = false;
+        let chromeClosed = false;
+        const actionCalls = [];
+        const page = {
+            goto: async (url)=>{
+                currentUrl = url;
+                actionCalls.push(`goto:${url}`);
+            },
+            click: async (selector)=>{
+                actionCalls.push(`click:${selector}`);
+            },
+            fill: async (selector, text)=>{
+                actionCalls.push(`fill:${selector}:${text}`);
+            },
+            keyboard: {
+                press: async (key)=>{
+                    actionCalls.push(`press:${key}`);
+                }
+            },
+            waitForTimeout: async (ms)=>{
+                actionCalls.push(`wait:${ms}`);
+            },
+            textContent: async (selector)=>{
+                actionCalls.push(`text:${selector}`);
+                return "body" === selector ? "Example page body content" : "Selector content";
+            },
+            evaluate: async (expression)=>{
+                actionCalls.push(`eval:${expression}`);
+                return {
+                    ok: true
+                };
+            },
+            screenshot: async ({ path })=>{
+                actionCalls.push(`screenshot:${path}`);
+                (0, external_node_fs_namespaceObject.writeFileSync)(path, "test image data");
+            },
+            title: async ()=>"Example Title",
+            url: ()=>currentUrl
+        };
+        const context = {
+            pages: ()=>[
+                    page
+                ],
+            newPage: async ()=>page
+        };
+        const browser = {
+            contexts: ()=>[
+                    context
+                ],
+            close: async ()=>{
+                browserClosed = true;
+            }
+        };
+        const testDeps = {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>browser
+                    }
+                }),
+            startChrome: async ()=>({
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{
+                        chromeClosed = true;
+                    }
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace
+        }, testDeps);
+        const result = await tool.invoke({
+            url: "https://example.com",
+            actions: [
+                {
+                    type: "click",
+                    selector: "#cta"
+                },
+                {
+                    type: "type",
+                    selector: "#query",
+                    text: "wingman",
+                    submit: true
+                },
+                {
+                    type: "extract_text",
+                    selector: "body",
+                    maxChars: 10
+                },
+                {
+                    type: "evaluate",
+                    expression: "window.location.href"
+                },
+                {
+                    type: "screenshot",
+                    path: "artifacts/shot.png",
+                    fullPage: false
+                }
+            ]
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.browser).toBe("chrome-cdp");
+        (0, external_vitest_namespaceObject.expect)(parsed.finalUrl).toBe("https://example.com");
+        (0, external_vitest_namespaceObject.expect)(parsed.title).toBe("Example Title");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults).toHaveLength(5);
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[2].text).toBe("Example pa");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[4].path).toBe("artifacts/shot.png");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("click:#cta");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("press:Enter");
+        (0, external_vitest_namespaceObject.expect)(browserClosed).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(chromeClosed).toBe(true);
+    });
+    (0, external_vitest_namespaceObject.it)("targets the most recently opened tab in the CDP context", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        const stalePageCalls = [];
+        const activePageCalls = [];
+        let currentUrl = "about:blank";
+        const stalePage = {
+            goto: async (url)=>{
+                stalePageCalls.push(`goto:${url}`);
+            },
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>({}),
+            screenshot: async ()=>{},
+            title: async ()=>"Stale",
+            url: ()=>"about:blank"
+        };
+        const activePage = {
+            goto: async (url)=>{
+                currentUrl = url;
+                activePageCalls.push(`goto:${url}`);
+            },
+            bringToFront: async ()=>{
+                activePageCalls.push("bringToFront");
+            },
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>({}),
+            screenshot: async ()=>{},
+            title: async ()=>"Active",
+            url: ()=>currentUrl
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>({
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    stalePage,
+                                                    activePage
+                                                ],
+                                            newPage: async ()=>activePage
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            startChrome: async ()=>({
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            url: "https://example.com"
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.finalUrl).toBe("https://example.com");
+        (0, external_vitest_namespaceObject.expect)(stalePageCalls).toHaveLength(0);
+        (0, external_vitest_namespaceObject.expect)(activePageCalls).toContain("bringToFront");
+        (0, external_vitest_namespaceObject.expect)(activePageCalls).toContain("goto:https://example.com");
+    });
+    (0, external_vitest_namespaceObject.it)("uses a context with pages when the first CDP context is empty", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        const hiddenContextCalls = [];
+        const visibleContextCalls = [];
+        let currentUrl = "about:blank";
+        const hiddenContext = {
+            pages: ()=>[],
+            newPage: async ()=>{
+                hiddenContextCalls.push("newPage");
+                return {
+                    goto: async (url)=>hiddenContextCalls.push(`goto:${url}`),
+                    click: async ()=>{},
+                    fill: async ()=>{},
+                    keyboard: {
+                        press: async ()=>{}
+                    },
+                    waitForTimeout: async ()=>{},
+                    textContent: async ()=>"",
+                    evaluate: async ()=>({}),
+                    screenshot: async ()=>{},
+                    title: async ()=>"Hidden",
+                    url: ()=>"about:blank"
+                };
+            }
+        };
+        const visiblePage = {
+            goto: async (url)=>{
+                currentUrl = url;
+                visibleContextCalls.push(`goto:${url}`);
+            },
+            bringToFront: async ()=>{
+                visibleContextCalls.push("bringToFront");
+            },
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>({}),
+            screenshot: async ()=>{},
+            title: async ()=>"Visible",
+            url: ()=>currentUrl
+        };
+        const visibleContext = {
+            pages: ()=>[
+                    visiblePage
+                ],
+            newPage: async ()=>visiblePage
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>({
+                                contexts: ()=>[
+                                        hiddenContext,
+                                        visibleContext
+                                    ],
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            startChrome: async ()=>({
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            url: "https://robinhood.com/login",
+            actions: [
+                {
+                    type: "wait",
+                    ms: 50
+                }
+            ]
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.finalUrl).toBe("https://robinhood.com/login");
+        (0, external_vitest_namespaceObject.expect)(hiddenContextCalls).toHaveLength(0);
+        (0, external_vitest_namespaceObject.expect)(visibleContextCalls).toContain("bringToFront");
+        (0, external_vitest_namespaceObject.expect)(visibleContextCalls).toContain("goto:https://robinhood.com/login");
+    });
+    (0, external_vitest_namespaceObject.it)("accepts larger top-level timeoutMs values for long browser runs", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let capturedLaunchTimeoutMs = 0;
+        let capturedCdpTimeoutMs = 0;
+        const page = {
+            goto: async ()=>{},
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Timeout Test",
+            url: ()=>"about:blank"
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace,
+            launchTimeoutMs: 15000
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async (_wsEndpoint, options)=>{
+                            capturedCdpTimeoutMs = options?.timeout ?? 0;
+                            return {
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            };
+                        }
+                    }
+                }),
+            startChrome: async (input)=>{
+                capturedLaunchTimeoutMs = input.launchTimeoutMs;
+                return {
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                };
+            },
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        await tool.invoke({
+            actions: [
+                {
+                    type: "evaluate",
+                    expression: "document.title"
+                }
+            ],
+            timeoutMs: 180000
+        });
+        (0, external_vitest_namespaceObject.expect)(capturedLaunchTimeoutMs).toBe(180000);
+        (0, external_vitest_namespaceObject.expect)(capturedCdpTimeoutMs).toBe(180000);
+    });
+    (0, external_vitest_namespaceObject.it)("accepts large extract_text maxChars values for long page content", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        const largeBody = "A".repeat(1020000);
+        const page = {
+            goto: async ()=>{},
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>largeBody,
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Large Extract",
+            url: ()=>"https://robinhood.com"
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>({
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            startChrome: async ()=>({
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            actions: [
+                {
+                    type: "extract_text",
+                    selector: "body",
+                    maxChars: 1000000
+                }
+            ],
+            timeoutMs: 60000
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[0].type).toBe("extract_text");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[0].selector).toBe("body");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[0].text.length).toBe(1000000);
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[0].truncated).toBe(true);
+    });
+    (0, external_vitest_namespaceObject.it)("uses persistent Playwright launch when preferred", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        const fakeChromePath = (0, external_node_path_namespaceObject.join)(tempDir, "chrome-bin");
+        (0, external_node_fs_namespaceObject.writeFileSync)(fakeChromePath, "fake chrome binary");
+        let launchCalled = false;
+        let closeCalled = false;
+        let currentUrl = "about:blank";
+        const page = {
+            goto: async (url)=>{
+                currentUrl = url;
+            },
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Persistent",
+            url: ()=>currentUrl
+        };
+        const result = await (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace,
+            preferPersistentLaunch: true,
+            defaultExecutablePath: fakeChromePath
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>{
+                            throw new Error("connectOverCDP should not be called");
+                        },
+                        launchPersistentContext: async ()=>{
+                            launchCalled = true;
+                            return {
+                                pages: ()=>[
+                                        page
+                                    ],
+                                newPage: async ()=>page,
+                                close: async ()=>{
+                                    closeCalled = true;
+                                }
+                            };
+                        }
+                    }
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        }).invoke({
+            url: "https://example.com",
+            actions: [
+                {
+                    type: "evaluate",
+                    expression: "document.title"
+                }
+            ]
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(launchCalled).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(closeCalled).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(parsed.browser).toBe("chrome-playwright");
+        (0, external_vitest_namespaceObject.expect)(parsed.transport).toBe("persistent-context");
+        (0, external_vitest_namespaceObject.expect)(parsed.finalUrl).toBe("https://example.com");
+    });
+    (0, external_vitest_namespaceObject.it)("falls back to persistent launch when CDP connection fails", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        const fakeChromePath = (0, external_node_path_namespaceObject.join)(tempDir, "chrome-bin");
+        (0, external_node_fs_namespaceObject.writeFileSync)(fakeChromePath, "fake chrome binary");
+        let startChromeCalled = false;
+        let cdpCalled = false;
+        let cdpChromeClosed = false;
+        let persistentClosed = false;
+        let currentUrl = "about:blank";
+        const page = {
+            goto: async (url)=>{
+                currentUrl = url;
+            },
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Fallback",
+            url: ()=>currentUrl
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace,
+            preferPersistentLaunch: false,
+            defaultExecutablePath: fakeChromePath
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>{
+                            cdpCalled = true;
+                            throw new Error("overCDP: Timeout 30000ms exceeded.");
+                        },
+                        launchPersistentContext: async ()=>({
+                                pages: ()=>[
+                                        page
+                                    ],
+                                newPage: async ()=>page,
+                                close: async ()=>{
+                                    persistentClosed = true;
+                                }
+                            })
+                    }
+                }),
+            startChrome: async ()=>{
+                startChromeCalled = true;
+                return {
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{
+                        cdpChromeClosed = true;
+                    }
+                };
+            },
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            url: "https://robinhood.com/login",
+            actions: [
+                {
+                    type: "evaluate",
+                    expression: "document.title"
+                }
+            ],
+            timeoutMs: 120000
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(startChromeCalled).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(cdpCalled).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(cdpChromeClosed).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(persistentClosed).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(parsed.browser).toBe("chrome-playwright");
+        (0, external_vitest_namespaceObject.expect)(parsed.transport).toBe("persistent-context");
+        (0, external_vitest_namespaceObject.expect)(parsed.finalUrl).toBe("https://robinhood.com/login");
+    });
+    (0, external_vitest_namespaceObject.it)("uses relay transport when explicitly requested", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let capturedRelayTimeout = 0;
+        let capturedRelayConfig = null;
+        let capturedWsEndpoint = "";
+        let startChromeCalled = false;
+        let currentUrl = "about:blank";
+        const page = {
+            goto: async (url)=>{
+                currentUrl = url;
+            },
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Relay Mode",
+            url: ()=>currentUrl
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace,
+            browserTransport: "relay",
+            relayConfig: {
+                enabled: true,
+                host: "127.0.0.1",
+                port: 18792,
+                requireAuth: true,
+                authToken: "test-relay-token-123456"
+            }
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async (wsEndpoint, options)=>{
+                            capturedWsEndpoint = wsEndpoint;
+                            capturedRelayTimeout = options?.timeout ?? 0;
+                            return {
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            };
+                        }
+                    }
+                }),
+            startChrome: async ()=>{
+                startChromeCalled = true;
+                return {
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                };
+            },
+            resolveRelayWsEndpoint: async (config, timeoutMs)=>{
+                capturedRelayConfig = {
+                    host: config.host,
+                    port: config.port
+                };
+                capturedRelayTimeout = timeoutMs;
+                return "ws://127.0.0.1:18792/cdp?token=test-relay-token-123456";
+            },
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            url: "https://example.com",
+            actions: [
+                {
+                    type: "evaluate",
+                    expression: "document.title"
+                }
+            ],
+            timeoutMs: 45000
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(startChromeCalled).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(parsed.transportRequested).toBe("relay");
+        (0, external_vitest_namespaceObject.expect)(parsed.transport).toBe("relay-cdp");
+        (0, external_vitest_namespaceObject.expect)(parsed.browser).toBe("chrome-relay");
+        (0, external_vitest_namespaceObject.expect)(parsed.finalUrl).toBe("https://example.com");
+        (0, external_vitest_namespaceObject.expect)(parsed.fallbackReason).toBeNull();
+        (0, external_vitest_namespaceObject.expect)(capturedRelayConfig?.host).toBe("127.0.0.1");
+        (0, external_vitest_namespaceObject.expect)(capturedRelayConfig?.port).toBe(18792);
+        (0, external_vitest_namespaceObject.expect)(capturedRelayTimeout).toBe(45000);
+        (0, external_vitest_namespaceObject.expect)(capturedWsEndpoint).toContain("/cdp");
+    });
+    (0, external_vitest_namespaceObject.it)("falls back to relay in auto mode when playwright startup fails", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let startChromeCalled = false;
+        let relayResolveCalled = false;
+        let currentUrl = "about:blank";
+        const page = {
+            goto: async (url)=>{
+                currentUrl = url;
+            },
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Auto Relay Fallback",
+            url: ()=>currentUrl
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace,
+            browserTransport: "auto",
+            relayConfig: {
+                enabled: true,
+                host: "127.0.0.1",
+                port: 18792,
+                requireAuth: false
+            }
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async (wsEndpoint)=>{
+                            if (wsEndpoint.includes("18792")) return {
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            };
+                            throw new Error("playwright cdp endpoint refused");
+                        }
+                    }
+                }),
+            startChrome: async ()=>{
+                startChromeCalled = true;
+                throw new Error("Failed to launch Chrome for CDP connection");
+            },
+            resolveRelayWsEndpoint: async ()=>{
+                relayResolveCalled = true;
+                return "ws://127.0.0.1:18792/cdp";
+            },
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            url: "https://example.com/auto",
+            actions: [
+                {
+                    type: "evaluate",
+                    expression: "document.title"
+                }
+            ],
+            timeoutMs: 90000
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(startChromeCalled).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(relayResolveCalled).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(parsed.transportRequested).toBe("auto");
+        (0, external_vitest_namespaceObject.expect)(parsed.transport).toBe("relay-cdp");
+        (0, external_vitest_namespaceObject.expect)(parsed.browser).toBe("chrome-relay");
+        (0, external_vitest_namespaceObject.expect)(parsed.fallbackReason).toContain("playwright initialization failed");
+        (0, external_vitest_namespaceObject.expect)(parsed.finalUrl).toBe("https://example.com/auto");
+    });
+    (0, external_vitest_namespaceObject.it)("does not fall back to relay when transport is explicitly playwright", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let relayResolveCalled = false;
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace,
+            browserTransport: "playwright",
+            relayConfig: {
+                enabled: true,
+                host: "127.0.0.1",
+                port: 18792,
+                requireAuth: false
+            }
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>{
+                            throw new Error("playwright cdp endpoint refused");
+                        }
+                    }
+                }),
+            startChrome: async ()=>{
+                throw new Error("CDP startup failed");
+            },
+            resolveRelayWsEndpoint: async ()=>{
+                relayResolveCalled = true;
+                return "ws://127.0.0.1:18792/cdp";
+            },
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            url: "https://example.com/playwright-only"
+        });
+        (0, external_vitest_namespaceObject.expect)(relayResolveCalled).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(String(result)).toContain("Error running browser_control");
+        (0, external_vitest_namespaceObject.expect)(String(result)).toContain("CDP startup failed");
+    });
+    (0, external_vitest_namespaceObject.it)("rejects screenshot paths that escape the workspace", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        const page = {
+            goto: async ()=>{},
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>({}),
+            screenshot: async ()=>{},
+            title: async ()=>"Example",
+            url: ()=>"about:blank"
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>({
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            startChrome: async ()=>({
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            actions: [
+                {
+                    type: "screenshot",
+                    path: "../escape.png"
+                }
+            ]
+        });
+        (0, external_vitest_namespaceObject.expect)(String(result)).toContain("Error running browser_control");
+        (0, external_vitest_namespaceObject.expect)(String(result)).toContain("inside the workspace");
+    });
+    (0, external_vitest_namespaceObject.it)("supports alias action types used by some agent prompts", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let currentUrl = "about:blank";
+        const actionCalls = [];
+        const page = {
+            goto: async (url)=>{
+                currentUrl = url;
+                actionCalls.push(`goto:${url}`);
+            },
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async (ms)=>{
+                actionCalls.push(`wait:${ms}`);
+            },
+            textContent: async (selector)=>{
+                actionCalls.push(`text:${selector}`);
+                return "Robinhood";
+            },
+            evaluate: async (expression)=>{
+                actionCalls.push(`eval:${expression}`);
+                return "Robinhood - Investing";
+            },
+            screenshot: async ({ path })=>{
+                actionCalls.push(`screenshot:${path}`);
+                (0, external_node_fs_namespaceObject.writeFileSync)(path, "test image data");
+            },
+            title: async ()=>"Robinhood - Investing",
+            url: ()=>currentUrl
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>({
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            startChrome: async ()=>({
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            url: "https://robinhood.com/?classic=1",
+            actions: [
+                {
+                    type: "url",
+                    url: "https://robinhood.com/?classic=1"
+                },
+                {
+                    type: "ms",
+                    ms: 4000
+                },
+                {
+                    type: "selector",
+                    selector: "body",
+                    maxChars: 4000
+                },
+                {
+                    type: "expression",
+                    expression: "document.title"
+                },
+                {
+                    type: "path",
+                    path: "robinhood.png",
+                    fullPage: true
+                }
+            ],
+            headless: true,
+            timeoutMs: 60000
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.finalUrl).toBe("https://robinhood.com/?classic=1");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[0].type).toBe("navigate");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[1].type).toBe("wait");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[2].type).toBe("extract_text");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[3].type).toBe("evaluate");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[4].type).toBe("screenshot");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[4].path).toBe("robinhood.png");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("goto:https://robinhood.com/?classic=1");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("wait:4000");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("text:body");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("eval:document.title");
+    });
+    (0, external_vitest_namespaceObject.it)("supports snapshot alias for screenshot actions", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let currentUrl = "about:blank";
+        const actionCalls = [];
+        const page = {
+            goto: async (url)=>{
+                currentUrl = url;
+                actionCalls.push(`goto:${url}`);
+            },
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ({ path })=>{
+                actionCalls.push(`screenshot:${path}`);
+                (0, external_node_fs_namespaceObject.writeFileSync)(path, "test image data");
+            },
+            title: async ()=>"Robinhood",
+            url: ()=>currentUrl
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>({
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            startChrome: async ()=>({
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            url: "https://robinhood.com/?classic=1",
+            actions: [
+                {
+                    type: "navigate",
+                    url: "https://robinhood.com/?classic=1"
+                },
+                {
+                    type: "wait",
+                    ms: 10
+                },
+                {
+                    type: "snapshot",
+                    path: "robinhood_classic.png",
+                    fullPage: true
+                }
+            ],
+            headless: true,
+            timeoutMs: 60000
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.finalUrl).toBe("https://robinhood.com/?classic=1");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[2].type).toBe("screenshot");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[2].path).toBe("robinhood_classic.png");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("goto:https://robinhood.com/?classic=1");
+    });
+    (0, external_vitest_namespaceObject.it)("supports additional action aliases for robust prompting", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let currentUrl = "about:blank";
+        const actionCalls = [];
+        const page = {
+            goto: async (url)=>{
+                currentUrl = url;
+                actionCalls.push(`goto:${url}`);
+            },
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async (ms)=>{
+                actionCalls.push(`wait:${ms}`);
+            },
+            textContent: async ()=>"",
+            evaluate: async (expression)=>{
+                actionCalls.push(`eval:${expression}`);
+                return "ok";
+            },
+            screenshot: async ({ path })=>{
+                actionCalls.push(`screenshot:${path}`);
+                (0, external_node_fs_namespaceObject.writeFileSync)(path, "test image data");
+            },
+            title: async ()=>"Alias Test",
+            url: ()=>currentUrl
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>({
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            startChrome: async ()=>({
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            url: "https://example.com",
+            actions: [
+                {
+                    type: "open",
+                    url: "https://example.com/docs"
+                },
+                {
+                    type: "sleep",
+                    ms: 25
+                },
+                {
+                    type: "js",
+                    expression: "document.title"
+                },
+                {
+                    type: "capture",
+                    path: "alias-capture.png",
+                    fullPage: true
+                }
+            ],
+            headless: true
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.finalUrl).toBe("https://example.com/docs");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[0].type).toBe("navigate");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[1].type).toBe("wait");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[2].type).toBe("evaluate");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[3].type).toBe("screenshot");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("goto:https://example.com/docs");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("wait:25");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("eval:document.title");
+    });
+    (0, external_vitest_namespaceObject.it)("supports extract alias for text extraction", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let currentUrl = "about:blank";
+        const actionCalls = [];
+        const page = {
+            goto: async (url)=>{
+                currentUrl = url;
+                actionCalls.push(`goto:${url}`);
+            },
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            waitForLoadState: async (state)=>{
+                actionCalls.push(`load:${state}`);
+            },
+            textContent: async (selector)=>{
+                actionCalls.push(`text:${selector}`);
+                return "Robinhood support content";
+            },
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Support",
+            url: ()=>currentUrl
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>({
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            startChrome: async ()=>({
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            url: "https://robinhood.com",
+            actions: [
+                {
+                    type: "goto",
+                    url: "https://robinhood.com/"
+                },
+                {
+                    type: "wait",
+                    load: "networkidle",
+                    timeoutMs: 30000
+                },
+                {
+                    type: "extract",
+                    selector: "body",
+                    maxChars: 5000
+                }
+            ],
+            headless: true,
+            timeoutMs: 60000
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.finalUrl).toBe("https://robinhood.com/");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[2].type).toBe("extract_text");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[2].selector).toBe("body");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("goto:https://robinhood.com/");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("load:networkidle");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("text:body");
+    });
+    (0, external_vitest_namespaceObject.it)("supports getContent alias for text extraction", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let currentUrl = "about:blank";
+        const actionCalls = [];
+        const page = {
+            goto: async (url)=>{
+                currentUrl = url;
+                actionCalls.push(`goto:${url}`);
+            },
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            waitForLoadState: async (state)=>{
+                actionCalls.push(`load:${state}`);
+            },
+            textContent: async (selector)=>{
+                actionCalls.push(`text:${selector}`);
+                return "Robinhood homepage content";
+            },
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Robinhood",
+            url: ()=>currentUrl
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>({
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            startChrome: async ()=>({
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            url: "https://robinhood.com/",
+            actions: [
+                {
+                    type: "goto",
+                    url: "https://robinhood.com/"
+                },
+                {
+                    type: "wait",
+                    load: "networkidle",
+                    timeoutMs: 30000
+                },
+                {
+                    type: "getContent",
+                    selector: "body",
+                    maxChars: 5000
+                }
+            ],
+            timeoutMs: 60000
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.finalUrl).toBe("https://robinhood.com/");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[2].type).toBe("extract_text");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[2].selector).toBe("body");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("goto:https://robinhood.com/");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("load:networkidle");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("text:body");
+    });
+    (0, external_vitest_namespaceObject.it)("supports querySelector alias for text extraction", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let currentUrl = "about:blank";
+        const actionCalls = [];
+        const page = {
+            goto: async (url)=>{
+                currentUrl = url;
+                actionCalls.push(`goto:${url}`);
+            },
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            waitForLoadState: async (state)=>{
+                actionCalls.push(`load:${state}`);
+            },
+            textContent: async (selector)=>{
+                actionCalls.push(`text:${selector}`);
+                return "Robinhood homepage content";
+            },
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Robinhood",
+            url: ()=>currentUrl
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>({
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            startChrome: async ()=>({
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            url: "https://robinhood.com",
+            actions: [
+                {
+                    type: "navigate",
+                    url: "https://robinhood.com"
+                },
+                {
+                    type: "wait",
+                    load: "networkidle",
+                    timeoutMs: 30000
+                },
+                {
+                    type: "querySelector",
+                    selector: "body",
+                    maxChars: 4000
+                }
+            ],
+            timeoutMs: 30000
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.finalUrl).toBe("https://robinhood.com");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[2].type).toBe("extract_text");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[2].selector).toBe("body");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("goto:https://robinhood.com");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("load:networkidle");
+        (0, external_vitest_namespaceObject.expect)(actionCalls).toContain("text:body");
+    });
+    (0, external_vitest_namespaceObject.it)("supports wait_for conditions", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        const waitCalls = [];
+        const page = {
+            goto: async ()=>{},
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            waitForSelector: async (selector)=>{
+                waitCalls.push(`selector:${selector}`);
+            },
+            waitForURL: async ()=>{
+                waitCalls.push("url");
+            },
+            waitForLoadState: async (state)=>{
+                waitCalls.push(`load:${state}`);
+            },
+            waitForFunction: async (expression)=>{
+                waitCalls.push(`fn:${expression}`);
+            },
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Wait For Test",
+            url: ()=>"https://example.com/dashboard"
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>({
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            startChrome: async ()=>({
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            actions: [
+                {
+                    type: "wait_for",
+                    selector: "#portfolio-root",
+                    url: "https://example.com/**",
+                    load: "domcontentloaded",
+                    fn: "document.readyState === 'complete'",
+                    timeoutMs: 25000
+                }
+            ],
+            headless: true,
+            timeoutMs: 60000
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[0].type).toBe("wait_for");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[0].timeoutMs).toBe(25000);
+        (0, external_vitest_namespaceObject.expect)(waitCalls).toContain("selector:#portfolio-root");
+        (0, external_vitest_namespaceObject.expect)(waitCalls).toContain("url");
+        (0, external_vitest_namespaceObject.expect)(waitCalls).toContain("load:domcontentloaded");
+        (0, external_vitest_namespaceObject.expect)(waitCalls).toContain("fn:document.readyState === 'complete'");
+    });
+    (0, external_vitest_namespaceObject.it)("supports wait with load/timeoutMs alias style", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        const waitCalls = [];
+        const page = {
+            goto: async ()=>{},
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            waitForLoadState: async (state)=>{
+                waitCalls.push(`load:${state}`);
+            },
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Wait Alias Test",
+            url: ()=>"https://support.robinhood.com"
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>({
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            startChrome: async ()=>({
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            actions: [
+                {
+                    type: "wait",
+                    load: "networkidle",
+                    timeoutMs: 180000
+                }
+            ],
+            headless: true
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[0].type).toBe("wait_for");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[0].load).toBe("networkidle");
+        (0, external_vitest_namespaceObject.expect)(parsed.actionResults[0].timeoutMs).toBe(180000);
+        (0, external_vitest_namespaceObject.expect)(waitCalls).toContain("load:networkidle");
+    });
+    (0, external_vitest_namespaceObject.it)("auto-provisions bundled wingman extension when configured path is missing", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let capturedChromeArgs = [];
+        const page = {
+            goto: async ()=>{},
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Bundled Extension",
+            url: ()=>"about:blank"
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace,
+            defaultExtensions: [
+                "wingman"
+            ]
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>({
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            startChrome: async (input)=>{
+                capturedChromeArgs = input.chromeArgs || [];
+                return {
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                };
+            },
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            actions: [
+                {
+                    type: "evaluate",
+                    expression: "document.title"
+                }
+            ]
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.extensions).toContain("wingman");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)((0, external_node_path_namespaceObject.join)(workspace, ".wingman", "browser-extensions", "wingman", "manifest.json"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(capturedChromeArgs.some((arg)=>arg.startsWith("--load-extension="))).toBe(true);
+    });
+    (0, external_vitest_namespaceObject.it)("resolves configured extension paths relative to config workspace", async ()=>{
+        const executionWorkspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const configWorkspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-config-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(executionWorkspace, configWorkspace, tempDir);
+        const extensionDir = (0, external_node_path_namespaceObject.join)(configWorkspace, ".wingman", "browser-extensions", "relay");
+        (0, external_node_fs_namespaceObject.mkdirSync)(extensionDir, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(extensionDir, "manifest.json"), JSON.stringify({
+            manifest_version: 3,
+            name: "Relay Test Extension",
+            version: "0.0.1"
+        }));
+        let capturedChromeArgs = [];
+        const page = {
+            goto: async ()=>{},
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Config Workspace Extension",
+            url: ()=>"about:blank"
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace: executionWorkspace,
+            configWorkspace,
+            defaultExtensions: [
+                "relay"
+            ]
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>({
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            startChrome: async (input)=>{
+                capturedChromeArgs = input.chromeArgs || [];
+                return {
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                };
+            },
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            actions: [
+                {
+                    type: "evaluate",
+                    expression: "document.title"
+                }
+            ]
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.extensions).toContain("relay");
+        (0, external_vitest_namespaceObject.expect)(capturedChromeArgs.some((arg)=>arg.includes(extensionDir))).toBe(true);
+    });
+    (0, external_vitest_namespaceObject.it)("uses persistent named browser profile when configured", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let capturedUserDataDir = "";
+        let capturedHeadless = null;
+        let capturedIgnoreDefaultArgs = [];
+        let removedTempDir = false;
+        const page = {
+            goto: async ()=>{},
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Profile Session",
+            url: ()=>"about:blank"
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace,
+            browserProfile: "trading"
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>{
+                            throw new Error("connectOverCDP should not be called");
+                        },
+                        launchPersistentContext: async (userDataDir, launchOptions)=>{
+                            capturedUserDataDir = userDataDir;
+                            capturedHeadless = launchOptions?.headless ?? null;
+                            capturedIgnoreDefaultArgs = launchOptions?.ignoreDefaultArgs || [];
+                            return {
+                                pages: ()=>[
+                                        page
+                                    ],
+                                newPage: async ()=>page,
+                                close: async ()=>{}
+                            };
+                        }
+                    }
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{
+                removedTempDir = true;
+            },
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            actions: [
+                {
+                    type: "evaluate",
+                    expression: "document.title"
+                }
+            ]
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.persistentProfile).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(parsed.profileId).toBe("trading");
+        (0, external_vitest_namespaceObject.expect)(parsed.profilePath).toBe(capturedUserDataDir);
+        (0, external_vitest_namespaceObject.expect)(parsed.transport).toBe("persistent-context");
+        (0, external_vitest_namespaceObject.expect)(parsed.mode).toBe("headed");
+        (0, external_vitest_namespaceObject.expect)(capturedHeadless).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(capturedIgnoreDefaultArgs).toContain("--password-store=basic");
+        (0, external_vitest_namespaceObject.expect)(capturedIgnoreDefaultArgs).toContain("--use-mock-keychain");
+        (0, external_vitest_namespaceObject.expect)(capturedUserDataDir).toContain(".wingman/browser-profiles/trading");
+        (0, external_vitest_namespaceObject.expect)(removedTempDir).toBe(false);
+    });
+    (0, external_vitest_namespaceObject.it)("honors headless requests for persistent browser profiles", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let capturedHeadless = null;
+        const page = {
+            goto: async ()=>{},
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Profile Session",
+            url: ()=>"about:blank"
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace,
+            browserProfile: "trading"
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>{
+                            throw new Error("connectOverCDP should not be called");
+                        },
+                        launchPersistentContext: async (_userDataDir, launchOptions)=>{
+                            capturedHeadless = launchOptions?.headless ?? null;
+                            return {
+                                pages: ()=>[
+                                        page
+                                    ],
+                                newPage: async ()=>page,
+                                close: async ()=>{}
+                            };
+                        }
+                    }
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            headless: true,
+            actions: [
+                {
+                    type: "evaluate",
+                    expression: "document.title"
+                }
+            ]
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.mode).toBe("headless");
+        (0, external_vitest_namespaceObject.expect)(capturedHeadless).toBe(true);
+    });
+    (0, external_vitest_namespaceObject.it)("retries CDP once for persistent profiles without switching transport", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let startChromeCalls = 0;
+        let connectCalls = 0;
+        let persistentLaunchCalled = false;
+        const page = {
+            goto: async ()=>{},
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Profile Retry",
+            url: ()=>"about:blank"
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace,
+            browserProfile: "trading",
+            preferPersistentLaunch: false
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>{
+                            connectCalls += 1;
+                            if (1 === connectCalls) throw new Error("overCDP: WebSocket error: ECONNREFUSED");
+                            return {
+                                contexts: ()=>[
+                                        {
+                                            pages: ()=>[
+                                                    page
+                                                ],
+                                            newPage: async ()=>page
+                                        }
+                                    ],
+                                close: async ()=>{}
+                            };
+                        },
+                        launchPersistentContext: async ()=>{
+                            persistentLaunchCalled = true;
+                            return {
+                                pages: ()=>[
+                                        page
+                                    ],
+                                newPage: async ()=>page
+                            };
+                        }
+                    }
+                }),
+            startChrome: async ()=>{
+                startChromeCalls += 1;
+                return {
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                };
+            },
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            actions: [
+                {
+                    type: "evaluate",
+                    expression: "document.title"
+                }
+            ]
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.persistentProfile).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(parsed.transport).toBe("cdp");
+        (0, external_vitest_namespaceObject.expect)(connectCalls).toBe(2);
+        (0, external_vitest_namespaceObject.expect)(startChromeCalls).toBe(2);
+        (0, external_vitest_namespaceObject.expect)(persistentLaunchCalled).toBe(false);
+    });
+    (0, external_vitest_namespaceObject.it)("falls back to persistent launch when persistent-profile CDP retry fails", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        let startChromeCalls = 0;
+        let connectCalls = 0;
+        let persistentLaunchCalled = false;
+        const page = {
+            goto: async ()=>{},
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Profile Fallback",
+            url: ()=>"about:blank"
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace,
+            browserProfile: "trading",
+            preferPersistentLaunch: false
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>{
+                            connectCalls += 1;
+                            throw new Error("overCDP: WebSocket error: ECONNREFUSED");
+                        },
+                        launchPersistentContext: async ()=>{
+                            persistentLaunchCalled = true;
+                            return {
+                                pages: ()=>[
+                                        page
+                                    ],
+                                newPage: async ()=>page
+                            };
+                        }
+                    }
+                }),
+            startChrome: async ()=>{
+                startChromeCalls += 1;
+                return {
+                    wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                    close: async ()=>{}
+                };
+            },
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            actions: [
+                {
+                    type: "evaluate",
+                    expression: "document.title"
+                }
+            ]
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.persistentProfile).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(parsed.transport).toBe("persistent-context");
+        (0, external_vitest_namespaceObject.expect)(connectCalls).toBe(2);
+        (0, external_vitest_namespaceObject.expect)(startChromeCalls).toBe(2);
+        (0, external_vitest_namespaceObject.expect)(persistentLaunchCalled).toBe(true);
+    });
+    (0, external_vitest_namespaceObject.it)("resolves persistent profile paths relative to config workspace", async ()=>{
+        const executionWorkspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const configWorkspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-config-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(executionWorkspace, configWorkspace, tempDir);
+        let capturedUserDataDir = "";
+        const page = {
+            goto: async ()=>{},
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Config Workspace Profile",
+            url: ()=>"about:blank"
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace: executionWorkspace,
+            configWorkspace,
+            browserProfile: "trading"
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>{
+                            throw new Error("connectOverCDP should not be called");
+                        },
+                        launchPersistentContext: async (userDataDir)=>{
+                            capturedUserDataDir = userDataDir;
+                            return {
+                                pages: ()=>[
+                                        page
+                                    ],
+                                newPage: async ()=>page,
+                                close: async ()=>{}
+                            };
+                        }
+                    }
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            actions: [
+                {
+                    type: "evaluate",
+                    expression: "document.title"
+                }
+            ]
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(parsed.persistentProfile).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(parsed.configWorkspace).toBe(configWorkspace);
+        (0, external_vitest_namespaceObject.expect)(parsed.executionWorkspace).toBe(executionWorkspace);
+        (0, external_vitest_namespaceObject.expect)(parsed.profilePath).toBe(capturedUserDataDir);
+        (0, external_vitest_namespaceObject.expect)(capturedUserDataDir).toBe((0, external_node_path_namespaceObject.join)(configWorkspace, ".wingman", "browser-profiles", "trading"));
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(capturedUserDataDir)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)((0, external_node_path_namespaceObject.join)(executionWorkspace, ".wingman", "browser-profiles", "trading"))).toBe(false);
+    });
+    (0, external_vitest_namespaceObject.it)("rejects concurrent runs when profile lock belongs to an active process", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        const profileDir = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "browser-profiles", "trading");
+        (0, external_node_fs_namespaceObject.mkdirSync)(profileDir, {
+            recursive: true
+        });
+        const blocker = (0, external_node_child_process_namespaceObject.spawn)("sleep", [
+            "30"
+        ], {
+            stdio: "ignore"
+        });
+        try {
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(profileDir, ".wingman-browser.lock"), JSON.stringify({
+                pid: blocker.pid
+            }));
+            let startChromeCalled = false;
+            const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+                workspace,
+                browserProfile: "trading"
+            }, {
+                importPlaywright: async ()=>({
+                        chromium: {
+                            connectOverCDP: async ()=>({
+                                    contexts: ()=>[],
+                                    close: async ()=>{}
+                                })
+                        }
+                    }),
+                startChrome: async ()=>{
+                    startChromeCalled = true;
+                    return {
+                        wsEndpoint: "ws://127.0.0.1:1234/devtools/browser/test",
+                        close: async ()=>{}
+                    };
+                },
+                mkTempDir: ()=>tempDir,
+                removeDir: ()=>{},
+                now: ()=>1700000000000
+            });
+            const result = await tool.invoke({
+                actions: [
+                    {
+                        type: "wait",
+                        ms: 10
+                    }
+                ]
+            });
+            (0, external_vitest_namespaceObject.expect)(startChromeCalled).toBe(false);
+            (0, external_vitest_namespaceObject.expect)(String(result)).toContain("already in use");
+        } finally{
+            try {
+                blocker.kill("SIGKILL");
+            } catch  {}
+        }
+    });
+    (0, external_vitest_namespaceObject.it)("recovers from stale profile lock when lock PID is no longer alive", async ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-workspace-"));
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-browser-temp-"));
+        workspaces.push(workspace, tempDir);
+        const profileDir = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "browser-profiles", "trading");
+        (0, external_node_fs_namespaceObject.mkdirSync)(profileDir, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(profileDir, ".wingman-browser.lock"), JSON.stringify({
+            pid: 999999,
+            createdAt: "2026-01-01T00:00:00.000Z"
+        }));
+        let startChromeCalled = false;
+        const page = {
+            goto: async ()=>{},
+            click: async ()=>{},
+            fill: async ()=>{},
+            keyboard: {
+                press: async ()=>{}
+            },
+            waitForTimeout: async ()=>{},
+            textContent: async ()=>"",
+            evaluate: async ()=>"ok",
+            screenshot: async ()=>{},
+            title: async ()=>"Recovered",
+            url: ()=>"about:blank"
+        };
+        const tool = (0, browser_control_cjs_namespaceObject.createBrowserControlTool)({
+            workspace,
+            browserProfile: "trading"
+        }, {
+            importPlaywright: async ()=>({
+                    chromium: {
+                        connectOverCDP: async ()=>{
+                            throw new Error("connectOverCDP should not be called");
+                        },
+                        launchPersistentContext: async ()=>({
+                                pages: ()=>[
+                                        page
+                                    ],
+                                newPage: async ()=>page,
+                                close: async ()=>{}
+                            })
+                    }
+                }),
+            mkTempDir: ()=>tempDir,
+            removeDir: ()=>{},
+            now: ()=>1700000000000
+        });
+        const result = await tool.invoke({
+            actions: [
+                {
+                    type: "evaluate",
+                    expression: "document.title"
+                }
+            ]
+        });
+        const parsed = JSON.parse(String(result));
+        (0, external_vitest_namespaceObject.expect)(startChromeCalled).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(parsed.persistentProfile).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(String(result)).not.toContain("already in use");
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});