@sylix/coworker 1.4.2 → 1.5.2

package/dist/services/browser/sandbox/__tests__/auto-connect.test.js

@@ -0,0 +1,643 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_http_1 = require("node:http");
+const node_events_1 = require("node:events");
+const node_path_1 = __importDefault(require("node:path"));
+const vitest_1 = require("vitest");
+const browser_manager_1 = require("../../browser-manager");
+const protocol_1 = require("../../protocol");
+class MockCDPSession {
+    constructor(targetId) {
+        this.targetId = targetId;
+    }
+    async send(method) {
+        (0, vitest_1.expect)(method).toBe("Target.getTargetInfo");
+        return {
+            targetInfo: {
+                targetId: this.targetId,
+            },
+        };
+    }
+    async detach() { }
+}
+class MockPage extends node_events_1.EventEmitter {
+    constructor(options = {}) {
+        super();
+        this.closed = false;
+        this.targetId = options.targetId ?? "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+        this.pageTitle = options.title ?? "";
+        this.pageUrl = options.url ?? "about:blank";
+    }
+    isClosed() {
+        return this.closed;
+    }
+    url() {
+        return this.pageUrl;
+    }
+    async title() {
+        return this.pageTitle;
+    }
+    async close() {
+        this.closed = true;
+        this.emit("close");
+    }
+}
+class MockContext {
+    constructor(pages = []) {
+        this.newPageCalls = 0;
+        this.closeCalls = 0;
+        this.browserHandle = null;
+        this.pagesList = pages;
+    }
+    setBrowser(browser) {
+        this.browserHandle = browser;
+    }
+    browser() {
+        return this.browserHandle;
+    }
+    pages() {
+        return this.pagesList;
+    }
+    async newCDPSession(page) {
+        return new MockCDPSession(page.targetId);
+    }
+    async newPage() {
+        this.newPageCalls += 1;
+        const page = new MockPage({
+            targetId: `${this.newPageCalls}`.padStart(32, "0"),
+        });
+        this.pagesList.push(page);
+        return page;
+    }
+    async close() {
+        this.closeCalls += 1;
+    }
+}
+class MockBrowser extends node_events_1.EventEmitter {
+    constructor(contexts = []) {
+        super();
+        this.closeCalls = 0;
+        this.newContextCalls = 0;
+        this.connected = true;
+        this.contextsList = contexts;
+    }
+    contexts() {
+        return this.contextsList;
+    }
+    async newContext() {
+        this.newContextCalls += 1;
+        const context = new MockContext();
+        this.contextsList.push(context);
+        return context;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async close() {
+        this.closeCalls += 1;
+        this.connected = false;
+        this.emit("disconnected");
+    }
+    disconnect() {
+        this.connected = false;
+        this.emit("disconnected");
+    }
+}
+function createEnoentError(filePath) {
+    const error = new Error(`ENOENT: no such file or directory, open '${filePath}'`);
+    error.code = "ENOENT";
+    return error;
+}
+function createManager(options = {}) {
+    const connectOverCDP = options.connectOverCDP ?? vitest_1.vi.fn();
+    const fetch = options.fetch ??
+        vitest_1.vi.fn(async () => {
+            throw new Error("unexpected fetch");
+        });
+    const readFile = options.readFile ??
+        vitest_1.vi.fn(async (filePath) => {
+            throw createEnoentError(filePath);
+        });
+    const launchPersistentContext = options.launchPersistentContext ?? vitest_1.vi.fn();
+    const manager = new browser_manager_1.BrowserManager(node_path_1.default.join("/tmp", "dev-browser-auto-connect-tests"), {
+        connectOverCDP: connectOverCDP,
+        fetch,
+        homedir: options.homedir ?? (() => "/Users/tester"),
+        launchPersistentContext: launchPersistentContext,
+        mkdir: vitest_1.vi.fn(async () => undefined),
+        platform: options.platform ?? "darwin",
+        readFile: readFile,
+    });
+    return {
+        manager,
+        connectOverCDP,
+        fetch,
+        launchPersistentContext,
+        readFile,
+    };
+}
+function getInternals(manager) {
+    return manager;
+}
+(0, vitest_1.afterEach)(() => {
+    vitest_1.vi.restoreAllMocks();
+});
+(0, vitest_1.describe)("BrowserManager auto-connect", () => {
+    (0, vitest_1.it)("passes ignoreHTTPSErrors to launched browsers and only relaunches when it changes", async () => {
+        const launchPersistentContext = vitest_1.vi.fn(async () => {
+            const context = new MockContext();
+            const browser = new MockBrowser([context]);
+            context.setBrowser(browser);
+            return context;
+        });
+        const { manager } = createManager({
+            launchPersistentContext,
+        });
+        const firstEntry = await manager.ensureBrowser("launched", {
+            ignoreHTTPSErrors: true,
+        });
+        const reusedEntry = await manager.ensureBrowser("launched");
+        (0, vitest_1.expect)(launchPersistentContext).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(launchPersistentContext).toHaveBeenNthCalledWith(1, node_path_1.default.join("/tmp/dev-browser-auto-connect-tests", "launched", "chromium-profile"), vitest_1.expect.objectContaining({
+            headless: false,
+            ignoreHTTPSErrors: true,
+        }));
+        (0, vitest_1.expect)(firstEntry.ignoreHTTPSErrors).toBe(true);
+        (0, vitest_1.expect)(reusedEntry).toBe(firstEntry);
+        const relaunchedEntry = await manager.ensureBrowser("launched", {
+            ignoreHTTPSErrors: false,
+        });
+        (0, vitest_1.expect)(launchPersistentContext).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(launchPersistentContext).toHaveBeenNthCalledWith(2, node_path_1.default.join("/tmp/dev-browser-auto-connect-tests", "launched", "chromium-profile"), vitest_1.expect.objectContaining({
+            headless: false,
+            ignoreHTTPSErrors: false,
+        }));
+        (0, vitest_1.expect)(relaunchedEntry).not.toBe(firstEntry);
+        (0, vitest_1.expect)(relaunchedEntry.ignoreHTTPSErrors).toBe(false);
+    });
+    (0, vitest_1.it)("preserves ignoreHTTPSErrors when relaunching for a headless change", async () => {
+        const launchPersistentContext = vitest_1.vi.fn(async () => {
+            const context = new MockContext();
+            const browser = new MockBrowser([context]);
+            context.setBrowser(browser);
+            return context;
+        });
+        const { manager } = createManager({
+            launchPersistentContext,
+        });
+        const firstEntry = await manager.ensureBrowser("launched", {
+            ignoreHTTPSErrors: true,
+        });
+        const relaunchedEntry = await manager.ensureBrowser("launched", {
+            headless: true,
+        });
+        (0, vitest_1.expect)(launchPersistentContext).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(launchPersistentContext).toHaveBeenNthCalledWith(2, node_path_1.default.join("/tmp/dev-browser-auto-connect-tests", "launched", "chromium-profile"), vitest_1.expect.objectContaining({
+            headless: true,
+            ignoreHTTPSErrors: true,
+        }));
+        (0, vitest_1.expect)(relaunchedEntry).not.toBe(firstEntry);
+        (0, vitest_1.expect)(relaunchedEntry.headless).toBe(true);
+        (0, vitest_1.expect)(relaunchedEntry.ignoreHTTPSErrors).toBe(true);
+    });
+    (0, vitest_1.it)("parses DevToolsActivePort and returns the browser websocket endpoint", async () => {
+        const homeDir = "/Users/tester";
+        const devToolsPath = node_path_1.default.join(homeDir, "Library", "Application Support", "Google", "Chrome", "DevToolsActivePort");
+        const websocketUrl = "ws://127.0.0.1:9333/devtools/browser/from-port-file";
+        const readFile = vitest_1.vi.fn(async (filePath) => {
+            if (filePath === devToolsPath) {
+                return "9333\n/devtools/browser/from-port-file\n";
+            }
+            throw createEnoentError(filePath);
+        });
+        const { manager } = createManager({
+            homedir: () => homeDir,
+            readFile,
+        });
+        await (0, vitest_1.expect)(getInternals(manager).readDevToolsActivePort()).resolves.toBe(websocketUrl);
+    });
+    (0, vitest_1.it)("checks Windows Chrome-family DevToolsActivePort locations", async () => {
+        const homeDir = "C:\\Users\\tester";
+        const devToolsPath = node_path_1.default.join(homeDir, "AppData", "Local", "Google", "Chrome", "User Data", "DevToolsActivePort");
+        const readFile = vitest_1.vi.fn(async (filePath) => {
+            if (filePath === devToolsPath) {
+                return "9222\n/devtools/browser/windows-port-file\n";
+            }
+            throw createEnoentError(filePath);
+        });
+        const { manager } = createManager({
+            homedir: () => homeDir,
+            platform: "win32",
+            readFile,
+        });
+        await (0, vitest_1.expect)(getInternals(manager).readDevToolsActivePort()).resolves.toBe("ws://127.0.0.1:9222/devtools/browser/windows-port-file");
+    });
+    (0, vitest_1.it)("returns null when DevToolsActivePort is missing", async () => {
+        const { manager } = createManager();
+        await (0, vitest_1.expect)(getInternals(manager).readDevToolsActivePort()).resolves.toBeNull();
+    });
+    (0, vitest_1.it)("ignores malformed DevToolsActivePort files", async () => {
+        const homeDir = "/Users/tester";
+        const malformedPath = node_path_1.default.join(homeDir, "Library", "Application Support", "Google", "Chrome", "DevToolsActivePort");
+        const readFile = vitest_1.vi.fn(async (filePath) => {
+            if (filePath === malformedPath) {
+                return "not-a-port\n/not-a-browser-path\n";
+            }
+            throw createEnoentError(filePath);
+        });
+        const { manager } = createManager({
+            homedir: () => homeDir,
+            readFile,
+        });
+        await (0, vitest_1.expect)(getInternals(manager).readDevToolsActivePort()).resolves.toBeNull();
+    });
+    (0, vitest_1.it)("discovers Chrome by trying DevToolsActivePort before common ports", async () => {
+        const homeDir = "/Users/tester";
+        const devToolsPath = node_path_1.default.join(homeDir, "Library", "Application Support", "Google", "Chrome", "DevToolsActivePort");
+        const requests = [];
+        const websocketUrl = "ws://127.0.0.1:9555/devtools/browser/from-discovery";
+        const readFile = vitest_1.vi.fn(async (filePath) => {
+            if (filePath === devToolsPath) {
+                return "9555\n/devtools/browser/from-discovery\n";
+            }
+            throw createEnoentError(filePath);
+        });
+        const fetch = vitest_1.vi.fn();
+        const { manager } = createManager({ fetch, homedir: () => homeDir, readFile });
+        await (0, vitest_1.expect)(getInternals(manager).discoverChrome()).resolves.toBe(websocketUrl);
+        (0, vitest_1.expect)(requests).toEqual([]);
+        (0, vitest_1.expect)(fetch).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)("probes a running CDP port via /json/version", async () => {
+        const websocketUrl = "ws://127.0.0.1/devtools/browser/probed";
+        const server = (0, node_http_1.createServer)((request, response) => {
+            if (request.url !== "/json/version") {
+                response.statusCode = 404;
+                response.end();
+                return;
+            }
+            response.setHeader("content-type", "application/json");
+            response.end(JSON.stringify({ webSocketDebuggerUrl: websocketUrl }));
+        });
+        try {
+            await new Promise((resolve, reject) => {
+                server.once("error", reject);
+                server.listen(0, "127.0.0.1", () => {
+                    server.off("error", reject);
+                    resolve();
+                });
+            });
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                throw new Error("failed to resolve server port");
+            }
+            const { manager } = createManager({
+                fetch: globalThis.fetch,
+            });
+            await (0, vitest_1.expect)(getInternals(manager).probePort(address.port)).resolves.toBe(websocketUrl);
+        }
+        finally {
+            await new Promise((resolve, reject) => {
+                server.close((error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        }
+    });
+    (0, vitest_1.it)("connectBrowser resolves HTTP endpoints, registers a connected browser, and creates fresh named pages", async () => {
+        const existingPage = new MockPage({
+            targetId: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+            title: "Existing tab",
+            url: "https://example.com/existing",
+        });
+        const context = new MockContext([existingPage]);
+        const browser = new MockBrowser([context]);
+        const connectOverCDP = vitest_1.vi.fn(async () => browser);
+        const fetch = vitest_1.vi.fn(async (input) => {
+            (0, vitest_1.expect)(String(input)).toBe("http://127.0.0.1:9222/json/version");
+            return new Response(JSON.stringify({
+                webSocketDebuggerUrl: "ws://127.0.0.1:9222/devtools/browser/connected-browser",
+            }), {
+                status: 200,
+                headers: {
+                    "content-type": "application/json",
+                },
+            });
+        });
+        const { manager } = createManager({
+            connectOverCDP,
+            fetch,
+        });
+        await manager.connectBrowser("attached", "http://127.0.0.1:9222");
+        const namedPage = await manager.getPage("attached", "dashboard");
+        (0, vitest_1.expect)(connectOverCDP).toHaveBeenCalledWith("ws://127.0.0.1:9222/devtools/browser/connected-browser");
+        (0, vitest_1.expect)(namedPage).not.toBe(existingPage);
+        (0, vitest_1.expect)(context.newPageCalls).toBe(1);
+        await (0, vitest_1.expect)(manager.listPages("attached")).resolves.toEqual([
+            {
+                id: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+                name: null,
+                title: "Existing tab",
+                url: "https://example.com/existing",
+            },
+            {
+                id: "00000000000000000000000000000001",
+                name: "dashboard",
+                title: "",
+                url: "about:blank",
+            },
+        ]);
+        (0, vitest_1.expect)(manager.listBrowsers()).toEqual([
+            {
+                name: "attached",
+                pages: ["dashboard"],
+                status: "connected",
+                type: "connected",
+            },
+        ]);
+    });
+    (0, vitest_1.it)("getBrowser returns connected entries without relaunching them", async () => {
+        const browser = new MockBrowser([new MockContext()]);
+        const connectOverCDP = vitest_1.vi.fn(async () => browser);
+        const { manager } = createManager({
+            connectOverCDP,
+        });
+        await manager.connectBrowser("attached", "ws://127.0.0.1:9222/devtools/browser/external-session");
+        const entry = manager.getBrowser("attached");
+        (0, vitest_1.expect)(entry).toMatchObject({
+            name: "attached",
+            type: "connected",
+            browser,
+        });
+        (0, vitest_1.expect)(connectOverCDP).toHaveBeenCalledTimes(1);
+        browser.disconnect();
+        (0, vitest_1.expect)(manager.getBrowser("attached")).toBeUndefined();
+    });
+    (0, vitest_1.it)("connectBrowser falls back to DevToolsActivePort when /json/version returns 404", async () => {
+        const homeDir = "/Users/tester";
+        const devToolsPath = node_path_1.default.join(homeDir, "Library", "Application Support", "Google", "Chrome", "DevToolsActivePort");
+        const browser = new MockBrowser([new MockContext()]);
+        const connectOverCDP = vitest_1.vi.fn(async () => browser);
+        const fetch = vitest_1.vi.fn(async (input) => {
+            (0, vitest_1.expect)(String(input)).toBe("http://127.0.0.1:9222/json/version");
+            return new Response("not found", { status: 404 });
+        });
+        const readFile = vitest_1.vi.fn(async (filePath) => {
+            if (filePath === devToolsPath) {
+                return "9222\n/devtools/browser/from-active-port\n";
+            }
+            throw createEnoentError(filePath);
+        });
+        const { manager } = createManager({
+            connectOverCDP,
+            fetch,
+            homedir: () => homeDir,
+            readFile,
+        });
+        await manager.connectBrowser("attached", "http://127.0.0.1:9222");
+        (0, vitest_1.expect)(connectOverCDP).toHaveBeenCalledWith("ws://127.0.0.1:9222/devtools/browser/from-active-port");
+    });
+    (0, vitest_1.it)("reports a helpful error when /json/version returns 404 and no matching DevToolsActivePort exists", async () => {
+        const homeDir = "/Users/tester";
+        const readFile = vitest_1.vi.fn(async (filePath) => {
+            if (filePath.endsWith("DevToolsActivePort")) {
+                return "9333\n/devtools/browser/different-port\n";
+            }
+            throw createEnoentError(filePath);
+        });
+        const fetch = vitest_1.vi.fn(async () => new Response("not found", { status: 404 }));
+        const { manager } = createManager({
+            fetch,
+            homedir: () => homeDir,
+            readFile,
+        });
+        let error;
+        try {
+            await manager.connectBrowser("missing", "http://127.0.0.1:9222");
+        }
+        catch (reason) {
+            error = reason;
+        }
+        (0, vitest_1.expect)(error).toBeInstanceOf(Error);
+        (0, vitest_1.expect)(error?.message).toMatch(/DevToolsActivePort/);
+        (0, vitest_1.expect)(error?.message).toMatch(/remote-debugging-port=9222/);
+    });
+    (0, vitest_1.it)("keeps external browsers alive on stopAll by only closing the CDP connection", async () => {
+        const context = new MockContext();
+        const browser = new MockBrowser([context]);
+        const connectOverCDP = vitest_1.vi.fn(async () => browser);
+        const { manager } = createManager({
+            connectOverCDP,
+        });
+        await manager.connectBrowser("attached", "ws://127.0.0.1:9222/devtools/browser/external-session");
+        await manager.stopAll();
+        (0, vitest_1.expect)(browser.closeCalls).toBe(1);
+        (0, vitest_1.expect)(context.closeCalls).toBe(0);
+        (0, vitest_1.expect)(manager.browserCount()).toBe(0);
+    });
+    (0, vitest_1.it)("autoConnect falls through discovery methods until a browser is found", async () => {
+        const browser = new MockBrowser([new MockContext()]);
+        const requests = [];
+        const connectOverCDP = vitest_1.vi.fn(async () => browser);
+        const fetch = vitest_1.vi.fn(async (input) => {
+            const url = String(input);
+            requests.push(url);
+            if (url === "http://127.0.0.1:9223/json/version") {
+                return new Response(JSON.stringify({
+                    webSocketDebuggerUrl: "ws://127.0.0.1:9223/devtools/browser/discovered",
+                }), {
+                    status: 200,
+                    headers: {
+                        "content-type": "application/json",
+                    },
+                });
+            }
+            throw new Error("connection refused");
+        });
+        const readFile = vitest_1.vi.fn(async (filePath) => {
+            throw createEnoentError(filePath);
+        });
+        const { manager } = createManager({
+            connectOverCDP,
+            fetch,
+            readFile,
+        });
+        await manager.autoConnect("auto-browser");
+        (0, vitest_1.expect)(requests.slice(0, 2)).toEqual([
+            "http://127.0.0.1:9222/json/version",
+            "http://127.0.0.1:9223/json/version",
+        ]);
+        (0, vitest_1.expect)(connectOverCDP).toHaveBeenCalledWith("ws://127.0.0.1:9223/devtools/browser/discovered");
+        (0, vitest_1.expect)(manager.listBrowsers()).toEqual([
+            {
+                name: "auto-browser",
+                pages: [],
+                status: "connected",
+                type: "connected",
+            },
+        ]);
+    });
+    (0, vitest_1.it)("autoConnect falls back from DevToolsActivePort to port probing when the direct websocket is stale", async () => {
+        const homeDir = "/Users/tester";
+        const devToolsPath = node_path_1.default.join(homeDir, "Library", "Application Support", "Google", "Chrome", "DevToolsActivePort");
+        const staleEndpoint = "ws://127.0.0.1:9222/devtools/browser/from-active-port";
+        const discoveredEndpoint = "ws://127.0.0.1:9223/devtools/browser/discovered";
+        const browser = new MockBrowser([new MockContext()]);
+        const requests = [];
+        const connectOverCDP = vitest_1.vi.fn(async (endpoint) => {
+            if (endpoint === staleEndpoint) {
+                throw new Error("stale DevToolsActivePort");
+            }
+            return browser;
+        });
+        const fetch = vitest_1.vi.fn(async (input) => {
+            const url = String(input);
+            requests.push(url);
+            if (url === "http://127.0.0.1:9222/json/version") {
+                return new Response("not found", { status: 404 });
+            }
+            if (url === "http://127.0.0.1:9223/json/version") {
+                return new Response(JSON.stringify({
+                    webSocketDebuggerUrl: discoveredEndpoint,
+                }), {
+                    status: 200,
+                    headers: {
+                        "content-type": "application/json",
+                    },
+                });
+            }
+            throw new Error("connection refused");
+        });
+        const readFile = vitest_1.vi.fn(async (filePath) => {
+            if (filePath === devToolsPath) {
+                return "9222\n/devtools/browser/from-active-port\n";
+            }
+            throw createEnoentError(filePath);
+        });
+        const { manager } = createManager({
+            connectOverCDP,
+            fetch,
+            homedir: () => homeDir,
+            readFile,
+        });
+        await manager.autoConnect("auto-browser");
+        (0, vitest_1.expect)(connectOverCDP).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(connectOverCDP).toHaveBeenNthCalledWith(1, staleEndpoint);
+        (0, vitest_1.expect)(connectOverCDP).toHaveBeenNthCalledWith(2, discoveredEndpoint);
+        (0, vitest_1.expect)(requests).toEqual([
+            "http://127.0.0.1:9222/json/version",
+            "http://127.0.0.1:9223/json/version",
+        ]);
+    });
+    (0, vitest_1.it)("reports a clear error when auto-discovery finds no running Chrome", async () => {
+        const readFile = vitest_1.vi.fn(async (filePath) => {
+            throw createEnoentError(filePath);
+        });
+        const fetch = vitest_1.vi.fn(async () => {
+            throw new Error("connection refused");
+        });
+        const { manager } = createManager({
+            fetch,
+            readFile,
+        });
+        await (0, vitest_1.expect)(manager.autoConnect("missing")).rejects.toThrowError(/remote-debugging-port=9222/);
+    });
+    (0, vitest_1.it)("reports a Windows-specific launch hint when auto-discovery fails on Windows", async () => {
+        const readFile = vitest_1.vi.fn(async () => {
+            throw createEnoentError("C:\\Users\\tester\\AppData\\Local\\Google\\Chrome\\User Data\\DevToolsActivePort");
+        });
+        const fetch = vitest_1.vi.fn(async () => {
+            throw new Error("connection refused");
+        });
+        const { manager } = createManager({
+            fetch,
+            platform: "win32",
+            readFile,
+        });
+        await (0, vitest_1.expect)(manager.autoConnect("missing")).rejects.toThrowError(/chrome\.exe --remote-debugging-port=9222/);
+    });
+});
+(0, vitest_1.describe)("protocol execute request", () => {
+    (0, vitest_1.it)('accepts connect="auto" and explicit CDP URLs', () => {
+        const autoResult = (0, protocol_1.parseRequest)(JSON.stringify({
+            id: "req-auto",
+            type: "execute",
+            browser: "default",
+            script: 'console.log("hi")',
+            connect: "auto",
+        }));
+        const manualResult = (0, protocol_1.parseRequest)(JSON.stringify({
+            id: "req-manual",
+            type: "execute",
+            browser: "default",
+            script: 'console.log("hi")',
+            connect: "http://127.0.0.1:9222",
+        }));
+        (0, vitest_1.expect)(autoResult).toEqual({
+            success: true,
+            request: {
+                id: "req-auto",
+                type: "execute",
+                browser: "default",
+                script: 'console.log("hi")',
+                connect: "auto",
+            },
+        });
+        (0, vitest_1.expect)(manualResult).toEqual({
+            success: true,
+            request: {
+                id: "req-manual",
+                type: "execute",
+                browser: "default",
+                script: 'console.log("hi")',
+                connect: "http://127.0.0.1:9222",
+            },
+        });
+    });
+    (0, vitest_1.it)("accepts an execution timeout", () => {
+        const result = (0, protocol_1.parseRequest)(JSON.stringify({
+            id: "req-timeout",
+            type: "execute",
+            browser: "default",
+            script: 'console.log("hi")',
+            timeoutMs: 10000,
+        }));
+        (0, vitest_1.expect)(result).toEqual({
+            success: true,
+            request: {
+                id: "req-timeout",
+                type: "execute",
+                browser: "default",
+                script: 'console.log("hi")',
+                timeoutMs: 10000,
+            },
+        });
+    });
+    (0, vitest_1.it)("accepts ignoreHTTPSErrors for execute requests", () => {
+        const result = (0, protocol_1.parseRequest)(JSON.stringify({
+            id: "req-ignore-https",
+            type: "execute",
+            browser: "default",
+            script: 'console.log("hi")',
+            ignoreHTTPSErrors: true,
+        }));
+        (0, vitest_1.expect)(result).toEqual({
+            success: true,
+            request: {
+                id: "req-ignore-https",
+                type: "execute",
+                browser: "default",
+                script: 'console.log("hi")',
+                ignoreHTTPSErrors: true,
+            },
+        });
+    });
+});
+//# sourceMappingURL=auto-connect.test.js.map