@farazirfan/costar-server-executor 1.0.0

package/dist/browser/constants.js

@@ -0,0 +1,9 @@
+export const DEFAULT_OPENCLAW_BROWSER_ENABLED = true;
+export const DEFAULT_BROWSER_EVALUATE_ENABLED = true;
+export const DEFAULT_OPENCLAW_BROWSER_COLOR = "#FF4500";
+export const DEFAULT_OPENCLAW_BROWSER_PROFILE_NAME = "openclaw";
+export const DEFAULT_BROWSER_DEFAULT_PROFILE_NAME = "chrome";
+export const DEFAULT_AI_SNAPSHOT_MAX_CHARS = 80_000;
+export const DEFAULT_AI_SNAPSHOT_EFFICIENT_MAX_CHARS = 10_000;
+export const DEFAULT_AI_SNAPSHOT_EFFICIENT_DEPTH = 6;
+//# sourceMappingURL=constants.js.map

package/dist/browser/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/browser/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,gCAAgC,GAAG,IAAI,CAAC;AACrD,MAAM,CAAC,MAAM,gCAAgC,GAAG,IAAI,CAAC;AACrD,MAAM,CAAC,MAAM,8BAA8B,GAAG,SAAS,CAAC;AACxD,MAAM,CAAC,MAAM,qCAAqC,GAAG,UAAU,CAAC;AAChE,MAAM,CAAC,MAAM,oCAAoC,GAAG,QAAQ,CAAC;AAC7D,MAAM,CAAC,MAAM,6BAA6B,GAAG,MAAM,CAAC;AACpD,MAAM,CAAC,MAAM,uCAAuC,GAAG,MAAM,CAAC;AAC9D,MAAM,CAAC,MAAM,mCAAmC,GAAG,CAAC,CAAC"}

package/dist/browser/control-service.d.ts

@@ -0,0 +1,6 @@
+import { type BrowserServerState } from "./server-context.js";
+export declare function getBrowserControlState(): BrowserServerState | null;
+export declare function createBrowserControlContext(): import("./server-context.types.js").BrowserRouteContext;
+export declare function startBrowserControlServiceFromConfig(): Promise<BrowserServerState | null>;
+export declare function stopBrowserControlService(): Promise<void>;
+//# sourceMappingURL=control-service.d.ts.map

package/dist/browser/control-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-service.d.ts","sourceRoot":"","sources":["../../src/browser/control-service.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,kBAAkB,EAA6B,MAAM,qBAAqB,CAAC;AAMzF,wBAAgB,sBAAsB,IAAI,kBAAkB,GAAG,IAAI,CAElE;AAED,wBAAgB,2BAA2B,4DAI1C;AAED,wBAAsB,oCAAoC,IAAI,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CA4B/F;AAED,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,IAAI,CAAC,CA6B/D"}

package/dist/browser/control-service.js

@@ -0,0 +1,73 @@
+import { loadConfig } from "../config/config.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+import { resolveBrowserConfig, resolveProfile } from "./config.js";
+import { ensureChromeExtensionRelayServer } from "./extension-relay.js";
+import { createBrowserRouteContext } from "./server-context.js";
+let state = null;
+const log = createSubsystemLogger("browser");
+const logService = log.child("service");
+export function getBrowserControlState() {
+    return state;
+}
+export function createBrowserControlContext() {
+    return createBrowserRouteContext({
+        getState: () => state,
+    });
+}
+export async function startBrowserControlServiceFromConfig() {
+    if (state)
+        return state;
+    const cfg = loadConfig();
+    const resolved = resolveBrowserConfig(cfg.browser, cfg);
+    if (!resolved.enabled)
+        return null;
+    state = {
+        server: null,
+        port: resolved.controlPort,
+        resolved,
+        profiles: new Map(),
+    };
+    // If any profile uses the Chrome extension relay, start the local relay server eagerly
+    // so the extension can connect before the first browser action.
+    for (const name of Object.keys(resolved.profiles)) {
+        const profile = resolveProfile(resolved, name);
+        if (!profile || profile.driver !== "extension")
+            continue;
+        await ensureChromeExtensionRelayServer({ cdpUrl: profile.cdpUrl }).catch((err) => {
+            logService.warn(`Chrome extension relay init failed for profile "${name}": ${String(err)}`);
+        });
+    }
+    logService.info(`Browser control service ready (profiles=${Object.keys(resolved.profiles).length})`);
+    return state;
+}
+export async function stopBrowserControlService() {
+    const current = state;
+    if (!current)
+        return;
+    const ctx = createBrowserRouteContext({
+        getState: () => state,
+    });
+    try {
+        for (const name of Object.keys(current.resolved.profiles)) {
+            try {
+                await ctx.forProfile(name).stopRunningBrowser();
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    catch (err) {
+        logService.warn(`openclaw browser stop failed: ${String(err)}`);
+    }
+    state = null;
+    // Optional: Playwright is not always available (e.g. embedded gateway builds).
+    try {
+        const mod = await import("./pw-ai.js");
+        await mod.closePlaywrightBrowserConnection();
+    }
+    catch {
+        // ignore
+    }
+}
+//# sourceMappingURL=control-service.js.map

package/dist/browser/control-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-service.js","sourceRoot":"","sources":["../../src/browser/control-service.ts"],"names":[],"mappings":"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"}

package/dist/browser/extension-relay.d.ts

@@ -0,0 +1,15 @@
+export type ChromeExtensionRelayServer = {
+    host: string;
+    port: number;
+    baseUrl: string;
+    cdpWsUrl: string;
+    extensionConnected: () => boolean;
+    stop: () => Promise<void>;
+};
+export declare function ensureChromeExtensionRelayServer(opts: {
+    cdpUrl: string;
+}): Promise<ChromeExtensionRelayServer>;
+export declare function stopChromeExtensionRelayServer(opts: {
+    cdpUrl: string;
+}): Promise<boolean>;
+//# sourceMappingURL=extension-relay.d.ts.map

package/dist/browser/extension-relay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-relay.d.ts","sourceRoot":"","sources":["../../src/browser/extension-relay.ts"],"names":[],"mappings":"AA8EA,MAAM,MAAM,0BAA0B,GAAG;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,OAAO,CAAC;IAClC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B,CAAC;AAkEF,wBAAsB,gCAAgC,CAAC,IAAI,EAAE;IAC3D,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,0BAA0B,CAAC,CA6ftC;AAED,wBAAsB,8BAA8B,CAAC,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAM/F"}

package/dist/browser/extension-relay.js

@@ -0,0 +1,542 @@
+import { createServer } from "node:http";
+import WebSocket, { WebSocketServer } from "ws";
+import { rawDataToString } from "../infra/ws.js";
+function isLoopbackHost(host) {
+    const h = host.trim().toLowerCase();
+    return (h === "localhost" ||
+        h === "127.0.0.1" ||
+        h === "0.0.0.0" ||
+        h === "[::1]" ||
+        h === "::1" ||
+        h === "[::]" ||
+        h === "::");
+}
+function isLoopbackAddress(ip) {
+    if (!ip)
+        return false;
+    if (ip === "127.0.0.1")
+        return true;
+    if (ip.startsWith("127."))
+        return true;
+    if (ip === "::1")
+        return true;
+    if (ip.startsWith("::ffff:127."))
+        return true;
+    return false;
+}
+function parseBaseUrl(raw) {
+    const parsed = new URL(raw.trim().replace(/\/$/, ""));
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`extension relay cdpUrl must be http(s), got ${parsed.protocol}`);
+    }
+    const host = parsed.hostname;
+    const port = parsed.port?.trim() !== "" ? Number(parsed.port) : parsed.protocol === "https:" ? 443 : 80;
+    if (!Number.isFinite(port) || port <= 0 || port > 65535) {
+        throw new Error(`extension relay cdpUrl has invalid port: ${parsed.port || "(empty)"}`);
+    }
+    return { host, port, baseUrl: parsed.toString().replace(/\/$/, "") };
+}
+function text(res, status, bodyText) {
+    const body = Buffer.from(bodyText);
+    res.write(`HTTP/1.1 ${status} ${status === 200 ? "OK" : "ERR"}\r\n` +
+        "Content-Type: text/plain; charset=utf-8\r\n" +
+        `Content-Length: ${body.length}\r\n` +
+        "Connection: close\r\n" +
+        "\r\n");
+    res.write(body);
+    res.end();
+}
+function rejectUpgrade(socket, status, bodyText) {
+    text(socket, status, bodyText);
+    try {
+        socket.destroy();
+    }
+    catch {
+        // ignore
+    }
+}
+const serversByPort = new Map();
+export async function ensureChromeExtensionRelayServer(opts) {
+    const info = parseBaseUrl(opts.cdpUrl);
+    if (!isLoopbackHost(info.host)) {
+        throw new Error(`extension relay requires loopback cdpUrl host (got ${info.host})`);
+    }
+    const existing = serversByPort.get(info.port);
+    if (existing)
+        return existing;
+    let extensionWs = null;
+    const cdpClients = new Set();
+    const connectedTargets = new Map();
+    const pendingExtension = new Map();
+    let nextExtensionId = 1;
+    const sendToExtension = async (payload) => {
+        const ws = extensionWs;
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            throw new Error("Chrome extension not connected");
+        }
+        ws.send(JSON.stringify(payload));
+        return await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                pendingExtension.delete(payload.id);
+                reject(new Error(`extension request timeout: ${payload.params.method}`));
+            }, 30_000);
+            pendingExtension.set(payload.id, { resolve, reject, timer });
+        });
+    };
+    const broadcastToCdpClients = (evt) => {
+        const msg = JSON.stringify(evt);
+        for (const ws of cdpClients) {
+            if (ws.readyState !== WebSocket.OPEN)
+                continue;
+            ws.send(msg);
+        }
+    };
+    const sendResponseToCdp = (ws, res) => {
+        if (ws.readyState !== WebSocket.OPEN)
+            return;
+        ws.send(JSON.stringify(res));
+    };
+    const ensureTargetEventsForClient = (ws, mode) => {
+        for (const target of connectedTargets.values()) {
+            if (mode === "autoAttach") {
+                ws.send(JSON.stringify({
+                    method: "Target.attachedToTarget",
+                    params: {
+                        sessionId: target.sessionId,
+                        targetInfo: { ...target.targetInfo, attached: true },
+                        waitingForDebugger: false,
+                    },
+                }));
+            }
+            else {
+                ws.send(JSON.stringify({
+                    method: "Target.targetCreated",
+                    params: { targetInfo: { ...target.targetInfo, attached: true } },
+                }));
+            }
+        }
+    };
+    const routeCdpCommand = async (cmd) => {
+        switch (cmd.method) {
+            case "Browser.getVersion":
+                return {
+                    protocolVersion: "1.3",
+                    product: "Chrome/OpenClaw-Extension-Relay",
+                    revision: "0",
+                    userAgent: "OpenClaw-Extension-Relay",
+                    jsVersion: "V8",
+                };
+            case "Browser.setDownloadBehavior":
+                return {};
+            case "Target.setAutoAttach":
+            case "Target.setDiscoverTargets":
+                return {};
+            case "Target.getTargets":
+                return {
+                    targetInfos: Array.from(connectedTargets.values()).map((t) => ({
+                        ...t.targetInfo,
+                        attached: true,
+                    })),
+                };
+            case "Target.getTargetInfo": {
+                const params = (cmd.params ?? {});
+                const targetId = typeof params.targetId === "string" ? params.targetId : undefined;
+                if (targetId) {
+                    for (const t of connectedTargets.values()) {
+                        if (t.targetId === targetId)
+                            return { targetInfo: t.targetInfo };
+                    }
+                }
+                if (cmd.sessionId && connectedTargets.has(cmd.sessionId)) {
+                    const t = connectedTargets.get(cmd.sessionId);
+                    if (t)
+                        return { targetInfo: t.targetInfo };
+                }
+                const first = Array.from(connectedTargets.values())[0];
+                return { targetInfo: first?.targetInfo };
+            }
+            case "Target.attachToTarget": {
+                const params = (cmd.params ?? {});
+                const targetId = typeof params.targetId === "string" ? params.targetId : undefined;
+                if (!targetId)
+                    throw new Error("targetId required");
+                for (const t of connectedTargets.values()) {
+                    if (t.targetId === targetId)
+                        return { sessionId: t.sessionId };
+                }
+                throw new Error("target not found");
+            }
+            default: {
+                const id = nextExtensionId++;
+                return await sendToExtension({
+                    id,
+                    method: "forwardCDPCommand",
+                    params: {
+                        method: cmd.method,
+                        sessionId: cmd.sessionId,
+                        params: cmd.params,
+                    },
+                });
+            }
+        }
+    };
+    const server = createServer((req, res) => {
+        const url = new URL(req.url ?? "/", info.baseUrl);
+        const path = url.pathname;
+        if (req.method === "HEAD" && path === "/") {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        if (path === "/") {
+            res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
+            res.end("OK");
+            return;
+        }
+        if (path === "/extension/status") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ connected: Boolean(extensionWs) }));
+            return;
+        }
+        const hostHeader = req.headers.host?.trim() || `${info.host}:${info.port}`;
+        const wsHost = `ws://${hostHeader}`;
+        const cdpWsUrl = `${wsHost}/cdp`;
+        if ((path === "/json/version" || path === "/json/version/") &&
+            (req.method === "GET" || req.method === "PUT")) {
+            const payload = {
+                Browser: "OpenClaw/extension-relay",
+                "Protocol-Version": "1.3",
+            };
+            // Only advertise the WS URL if a real extension is connected.
+            if (extensionWs)
+                payload.webSocketDebuggerUrl = cdpWsUrl;
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(payload));
+            return;
+        }
+        const listPaths = new Set(["/json", "/json/", "/json/list", "/json/list/"]);
+        if (listPaths.has(path) && (req.method === "GET" || req.method === "PUT")) {
+            const list = Array.from(connectedTargets.values()).map((t) => ({
+                id: t.targetId,
+                type: t.targetInfo.type ?? "page",
+                title: t.targetInfo.title ?? "",
+                description: t.targetInfo.title ?? "",
+                url: t.targetInfo.url ?? "",
+                webSocketDebuggerUrl: cdpWsUrl,
+                devtoolsFrontendUrl: `/devtools/inspector.html?ws=${cdpWsUrl.replace("ws://", "")}`,
+            }));
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(list));
+            return;
+        }
+        const activateMatch = path.match(/^\/json\/activate\/(.+)$/);
+        if (activateMatch && (req.method === "GET" || req.method === "PUT")) {
+            const targetId = decodeURIComponent(activateMatch[1] ?? "").trim();
+            if (!targetId) {
+                res.writeHead(400);
+                res.end("targetId required");
+                return;
+            }
+            void (async () => {
+                try {
+                    await sendToExtension({
+                        id: nextExtensionId++,
+                        method: "forwardCDPCommand",
+                        params: { method: "Target.activateTarget", params: { targetId } },
+                    });
+                }
+                catch {
+                    // ignore
+                }
+            })();
+            res.writeHead(200);
+            res.end("OK");
+            return;
+        }
+        const closeMatch = path.match(/^\/json\/close\/(.+)$/);
+        if (closeMatch && (req.method === "GET" || req.method === "PUT")) {
+            const targetId = decodeURIComponent(closeMatch[1] ?? "").trim();
+            if (!targetId) {
+                res.writeHead(400);
+                res.end("targetId required");
+                return;
+            }
+            void (async () => {
+                try {
+                    await sendToExtension({
+                        id: nextExtensionId++,
+                        method: "forwardCDPCommand",
+                        params: { method: "Target.closeTarget", params: { targetId } },
+                    });
+                }
+                catch {
+                    // ignore
+                }
+            })();
+            res.writeHead(200);
+            res.end("OK");
+            return;
+        }
+        res.writeHead(404);
+        res.end("not found");
+    });
+    const wssExtension = new WebSocketServer({ noServer: true });
+    const wssCdp = new WebSocketServer({ noServer: true });
+    server.on("upgrade", (req, socket, head) => {
+        const url = new URL(req.url ?? "/", info.baseUrl);
+        const pathname = url.pathname;
+        const remote = req.socket.remoteAddress;
+        if (!isLoopbackAddress(remote)) {
+            rejectUpgrade(socket, 403, "Forbidden");
+            return;
+        }
+        if (pathname === "/extension") {
+            if (extensionWs) {
+                rejectUpgrade(socket, 409, "Extension already connected");
+                return;
+            }
+            wssExtension.handleUpgrade(req, socket, head, (ws) => {
+                wssExtension.emit("connection", ws, req);
+            });
+            return;
+        }
+        if (pathname === "/cdp") {
+            if (!extensionWs) {
+                rejectUpgrade(socket, 503, "Extension not connected");
+                return;
+            }
+            wssCdp.handleUpgrade(req, socket, head, (ws) => {
+                wssCdp.emit("connection", ws, req);
+            });
+            return;
+        }
+        rejectUpgrade(socket, 404, "Not Found");
+    });
+    wssExtension.on("connection", (ws) => {
+        extensionWs = ws;
+        const ping = setInterval(() => {
+            if (ws.readyState !== WebSocket.OPEN)
+                return;
+            ws.send(JSON.stringify({ method: "ping" }));
+        }, 5000);
+        ws.on("message", (data) => {
+            let parsed = null;
+            try {
+                parsed = JSON.parse(rawDataToString(data));
+            }
+            catch {
+                return;
+            }
+            if (parsed && typeof parsed === "object" && "id" in parsed && typeof parsed.id === "number") {
+                const pending = pendingExtension.get(parsed.id);
+                if (!pending)
+                    return;
+                pendingExtension.delete(parsed.id);
+                clearTimeout(pending.timer);
+                if ("error" in parsed && typeof parsed.error === "string" && parsed.error.trim()) {
+                    pending.reject(new Error(parsed.error));
+                }
+                else {
+                    pending.resolve(parsed.result);
+                }
+                return;
+            }
+            if (parsed && typeof parsed === "object" && "method" in parsed) {
+                if (parsed.method === "pong")
+                    return;
+                if (parsed.method !== "forwardCDPEvent")
+                    return;
+                const evt = parsed;
+                const method = evt.params?.method;
+                const params = evt.params?.params;
+                const sessionId = evt.params?.sessionId;
+                if (!method || typeof method !== "string")
+                    return;
+                if (method === "Target.attachedToTarget") {
+                    const attached = (params ?? {});
+                    const targetType = attached?.targetInfo?.type ?? "page";
+                    if (targetType !== "page")
+                        return;
+                    if (attached?.sessionId && attached?.targetInfo?.targetId) {
+                        const prev = connectedTargets.get(attached.sessionId);
+                        const nextTargetId = attached.targetInfo.targetId;
+                        const prevTargetId = prev?.targetId;
+                        const changedTarget = Boolean(prev && prevTargetId && prevTargetId !== nextTargetId);
+                        connectedTargets.set(attached.sessionId, {
+                            sessionId: attached.sessionId,
+                            targetId: nextTargetId,
+                            targetInfo: attached.targetInfo,
+                        });
+                        if (changedTarget && prevTargetId) {
+                            broadcastToCdpClients({
+                                method: "Target.detachedFromTarget",
+                                params: { sessionId: attached.sessionId, targetId: prevTargetId },
+                                sessionId: attached.sessionId,
+                            });
+                        }
+                        if (!prev || changedTarget) {
+                            broadcastToCdpClients({ method, params, sessionId });
+                        }
+                        return;
+                    }
+                }
+                if (method === "Target.detachedFromTarget") {
+                    const detached = (params ?? {});
+                    if (detached?.sessionId)
+                        connectedTargets.delete(detached.sessionId);
+                    broadcastToCdpClients({ method, params, sessionId });
+                    return;
+                }
+                // Keep cached tab metadata fresh for /json/list.
+                // After navigation, Chrome updates URL/title via Target.targetInfoChanged.
+                if (method === "Target.targetInfoChanged") {
+                    const changed = (params ?? {});
+                    const targetInfo = changed?.targetInfo;
+                    const targetId = targetInfo?.targetId;
+                    if (targetId && (targetInfo?.type ?? "page") === "page") {
+                        for (const [sid, target] of connectedTargets) {
+                            if (target.targetId !== targetId)
+                                continue;
+                            connectedTargets.set(sid, {
+                                ...target,
+                                targetInfo: { ...target.targetInfo, ...targetInfo },
+                            });
+                        }
+                    }
+                }
+                broadcastToCdpClients({ method, params, sessionId });
+            }
+        });
+        ws.on("close", () => {
+            clearInterval(ping);
+            extensionWs = null;
+            for (const [, pending] of pendingExtension) {
+                clearTimeout(pending.timer);
+                pending.reject(new Error("extension disconnected"));
+            }
+            pendingExtension.clear();
+            connectedTargets.clear();
+            for (const client of cdpClients) {
+                try {
+                    client.close(1011, "extension disconnected");
+                }
+                catch {
+                    // ignore
+                }
+            }
+            cdpClients.clear();
+        });
+    });
+    wssCdp.on("connection", (ws) => {
+        cdpClients.add(ws);
+        ws.on("message", async (data) => {
+            let cmd = null;
+            try {
+                cmd = JSON.parse(rawDataToString(data));
+            }
+            catch {
+                return;
+            }
+            if (!cmd || typeof cmd !== "object")
+                return;
+            if (typeof cmd.id !== "number" || typeof cmd.method !== "string")
+                return;
+            if (!extensionWs) {
+                sendResponseToCdp(ws, {
+                    id: cmd.id,
+                    sessionId: cmd.sessionId,
+                    error: { message: "Extension not connected" },
+                });
+                return;
+            }
+            try {
+                const result = await routeCdpCommand(cmd);
+                if (cmd.method === "Target.setAutoAttach" && !cmd.sessionId) {
+                    ensureTargetEventsForClient(ws, "autoAttach");
+                }
+                if (cmd.method === "Target.setDiscoverTargets") {
+                    const discover = (cmd.params ?? {});
+                    if (discover.discover === true) {
+                        ensureTargetEventsForClient(ws, "discover");
+                    }
+                }
+                if (cmd.method === "Target.attachToTarget") {
+                    const params = (cmd.params ?? {});
+                    const targetId = typeof params.targetId === "string" ? params.targetId : undefined;
+                    if (targetId) {
+                        const target = Array.from(connectedTargets.values()).find((t) => t.targetId === targetId);
+                        if (target) {
+                            ws.send(JSON.stringify({
+                                method: "Target.attachedToTarget",
+                                params: {
+                                    sessionId: target.sessionId,
+                                    targetInfo: { ...target.targetInfo, attached: true },
+                                    waitingForDebugger: false,
+                                },
+                            }));
+                        }
+                    }
+                }
+                sendResponseToCdp(ws, { id: cmd.id, sessionId: cmd.sessionId, result });
+            }
+            catch (err) {
+                sendResponseToCdp(ws, {
+                    id: cmd.id,
+                    sessionId: cmd.sessionId,
+                    error: { message: err instanceof Error ? err.message : String(err) },
+                });
+            }
+        });
+        ws.on("close", () => {
+            cdpClients.delete(ws);
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.listen(info.port, info.host, () => resolve());
+        server.once("error", reject);
+    });
+    const addr = server.address();
+    const port = addr?.port ?? info.port;
+    const host = info.host;
+    const baseUrl = `${new URL(info.baseUrl).protocol}//${host}:${port}`;
+    const relay = {
+        host,
+        port,
+        baseUrl,
+        cdpWsUrl: `ws://${host}:${port}/cdp`,
+        extensionConnected: () => Boolean(extensionWs),
+        stop: async () => {
+            serversByPort.delete(port);
+            try {
+                extensionWs?.close(1001, "server stopping");
+            }
+            catch {
+                // ignore
+            }
+            for (const ws of cdpClients) {
+                try {
+                    ws.close(1001, "server stopping");
+                }
+                catch {
+                    // ignore
+                }
+            }
+            await new Promise((resolve) => {
+                server.close(() => resolve());
+            });
+            wssExtension.close();
+            wssCdp.close();
+        },
+    };
+    serversByPort.set(port, relay);
+    return relay;
+}
+export async function stopChromeExtensionRelayServer(opts) {
+    const info = parseBaseUrl(opts.cdpUrl);
+    const existing = serversByPort.get(info.port);
+    if (!existing)
+        return false;
+    await existing.stop();
+    return true;
+}
+//# sourceMappingURL=extension-relay.js.map