@sensaiorg/adapter-chrome 0.1.0

package/dist/tools/chrome-tools.test.js

@@ -0,0 +1,442 @@
+"use strict";
+/**
+ * Unit tests for CdpEventCollector.
+ *
+ * CdpEventCollector is already exported from chrome-tools.ts, no modifications needed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const chrome_tools_js_1 = require("./chrome-tools.js");
+/** Creates a minimal CdpBridge mock that captures event handlers. */
+function createMockBridge() {
+    const handlers = new Map();
+    const bridge = {
+        onEvent: vitest_1.vi.fn((method, handler) => {
+            const list = handlers.get(method) ?? [];
+            list.push(handler);
+            handlers.set(method, list);
+        }),
+        send: vitest_1.vi.fn(async () => undefined),
+    };
+    /** Simulate a CDP event arriving. */
+    function emit(method, params) {
+        for (const h of handlers.get(method) ?? []) {
+            h(params);
+        }
+    }
+    return { bridge, emit };
+}
+/** Enable domains on a collector with the mock bridge. */
+async function setup() {
+    const collector = new chrome_tools_js_1.CdpEventCollector();
+    const { bridge, emit } = createMockBridge();
+    await collector.enableDomains(bridge);
+    return { collector, bridge, emit };
+}
+/* ── Console message buffering ────────────────────────────────────── */
+(0, vitest_1.describe)("CdpEventCollector", () => {
+    (0, vitest_1.describe)("console messages", () => {
+        (0, vitest_1.it)("buffers a console log with timestamp", async () => {
+            const { collector, emit } = await setup();
+            emit("Runtime.consoleAPICalled", {
+                type: "log",
+                args: [{ value: "hello world" }],
+                timestamp: 1000,
+            });
+            const logs = collector.getConsoleLogs();
+            (0, vitest_1.expect)(logs).toHaveLength(1);
+            (0, vitest_1.expect)(logs[0]).toEqual({
+                level: "log",
+                text: "hello world",
+                timestamp: 1000,
+                url: undefined,
+                line: undefined,
+            });
+        });
+        (0, vitest_1.it)("concatenates multiple args with a space", async () => {
+            const { collector, emit } = await setup();
+            emit("Runtime.consoleAPICalled", {
+                type: "log",
+                args: [{ value: "a" }, { value: "b" }, { description: "c-desc" }],
+                timestamp: 2000,
+            });
+            (0, vitest_1.expect)(collector.getConsoleLogs()[0].text).toBe("a b c-desc");
+        });
+        (0, vitest_1.it)("captures source location from stackTrace", async () => {
+            const { collector, emit } = await setup();
+            emit("Runtime.consoleAPICalled", {
+                type: "warn",
+                args: [{ value: "warning" }],
+                timestamp: 3000,
+                stackTrace: {
+                    callFrames: [{ url: "https://example.com/app.js", lineNumber: 42 }],
+                },
+            });
+            const entry = collector.getConsoleLogs()[0];
+            (0, vitest_1.expect)(entry.url).toBe("https://example.com/app.js");
+            (0, vitest_1.expect)(entry.line).toBe(42);
+        });
+        (0, vitest_1.it)("buffers Runtime.exceptionThrown as error level", async () => {
+            const { collector, emit } = await setup();
+            emit("Runtime.exceptionThrown", {
+                timestamp: 5000,
+                exceptionDetails: {
+                    text: "Uncaught Error",
+                    exception: { description: "TypeError: x is not a function" },
+                    url: "https://example.com/main.js",
+                    lineNumber: 10,
+                },
+            });
+            const logs = collector.getConsoleLogs();
+            (0, vitest_1.expect)(logs).toHaveLength(1);
+            (0, vitest_1.expect)(logs[0].level).toBe("error");
+            (0, vitest_1.expect)(logs[0].text).toBe("TypeError: x is not a function");
+            (0, vitest_1.expect)(logs[0].url).toBe("https://example.com/main.js");
+            (0, vitest_1.expect)(logs[0].line).toBe(10);
+        });
+        (0, vitest_1.it)("falls back to text when exception description is missing", async () => {
+            const { collector, emit } = await setup();
+            emit("Runtime.exceptionThrown", {
+                timestamp: 5000,
+                exceptionDetails: { text: "Uncaught SyntaxError" },
+            });
+            (0, vitest_1.expect)(collector.getConsoleLogs()[0].text).toBe("Uncaught SyntaxError");
+        });
+        (0, vitest_1.it)("falls back to 'Unknown exception' when all fields missing", async () => {
+            const { collector, emit } = await setup();
+            emit("Runtime.exceptionThrown", { timestamp: 5000 });
+            (0, vitest_1.expect)(collector.getConsoleLogs()[0].text).toBe("Unknown exception");
+        });
+        (0, vitest_1.it)("getConsoleLogs() returns all buffered messages", async () => {
+            const { collector, emit } = await setup();
+            for (let i = 0; i < 10; i++) {
+                emit("Runtime.consoleAPICalled", {
+                    type: "log",
+                    args: [{ value: `msg-${i}` }],
+                    timestamp: 1000 + i,
+                });
+            }
+            (0, vitest_1.expect)(collector.getConsoleLogs()).toHaveLength(10);
+        });
+        (0, vitest_1.it)("getConsoleLogs(maxCount) returns the most recent entries", async () => {
+            const { collector, emit } = await setup();
+            for (let i = 0; i < 10; i++) {
+                emit("Runtime.consoleAPICalled", {
+                    type: "log",
+                    args: [{ value: `msg-${i}` }],
+                    timestamp: 1000 + i,
+                });
+            }
+            const last3 = collector.getConsoleLogs(3);
+            (0, vitest_1.expect)(last3).toHaveLength(3);
+            (0, vitest_1.expect)(last3[0].text).toBe("msg-7");
+            (0, vitest_1.expect)(last3[2].text).toBe("msg-9");
+        });
+    });
+    /* ── Console buffer size limit ──────────────────────────────────── */
+    (0, vitest_1.describe)("console buffer eviction", () => {
+        (0, vitest_1.it)("enforces max buffer size of 500, evicting oldest entries", async () => {
+            const { collector, emit } = await setup();
+            for (let i = 0; i < 520; i++) {
+                emit("Runtime.consoleAPICalled", {
+                    type: "log",
+                    args: [{ value: `entry-${i}` }],
+                    timestamp: i,
+                });
+            }
+            const logs = collector.getConsoleLogs();
+            (0, vitest_1.expect)(logs).toHaveLength(500);
+            // Oldest 20 entries (0..19) should have been evicted
+            (0, vitest_1.expect)(logs[0].text).toBe("entry-20");
+            (0, vitest_1.expect)(logs[499].text).toBe("entry-519");
+        });
+    });
+    /* ── Network request buffering ──────────────────────────────────── */
+    (0, vitest_1.describe)("network requests", () => {
+        (0, vitest_1.it)("buffers a network request with timing info", async () => {
+            const { collector, emit } = await setup();
+            emit("Network.requestWillBeSent", {
+                requestId: "r1",
+                request: { method: "GET", url: "https://api.example.com/data" },
+                type: "Fetch",
+                timestamp: 100.5,
+            });
+            emit("Network.responseReceived", {
+                requestId: "r1",
+                response: { status: 200, statusText: "OK" },
+                timestamp: 100.8,
+            });
+            emit("Network.loadingFinished", {
+                requestId: "r1",
+                encodedDataLength: 1234,
+                timestamp: 100.9,
+            });
+            const entries = collector.getNetworkEntries();
+            (0, vitest_1.expect)(entries).toHaveLength(1);
+            (0, vitest_1.expect)(entries[0]).toMatchObject({
+                requestId: "r1",
+                method: "GET",
+                url: "https://api.example.com/data",
+                status: 200,
+                statusText: "OK",
+                type: "Fetch",
+                startTime: 100.5,
+                endTime: 100.9,
+                encodedDataLength: 1234,
+            });
+        });
+        (0, vitest_1.it)("records network errors via loadingFailed", async () => {
+            const { collector, emit } = await setup();
+            emit("Network.requestWillBeSent", {
+                requestId: "r2",
+                request: { method: "POST", url: "https://api.example.com/fail" },
+                timestamp: 200,
+            });
+            emit("Network.loadingFailed", {
+                requestId: "r2",
+                errorText: "net::ERR_CONNECTION_REFUSED",
+                timestamp: 201,
+            });
+            const entries = collector.getNetworkEntries();
+            (0, vitest_1.expect)(entries).toHaveLength(1);
+            (0, vitest_1.expect)(entries[0].error).toBe("net::ERR_CONNECTION_REFUSED");
+            (0, vitest_1.expect)(entries[0].endTime).toBe(201);
+        });
+        (0, vitest_1.it)("getNetworkEntries() returns all buffered requests", async () => {
+            const { collector, emit } = await setup();
+            for (let i = 0; i < 5; i++) {
+                emit("Network.requestWillBeSent", {
+                    requestId: `r${i}`,
+                    request: { method: "GET", url: `https://example.com/${i}` },
+                    timestamp: i,
+                });
+            }
+            (0, vitest_1.expect)(collector.getNetworkEntries()).toHaveLength(5);
+        });
+        (0, vitest_1.it)("getNetworkEntries(maxCount) returns the most recent entries", async () => {
+            const { collector, emit } = await setup();
+            for (let i = 0; i < 10; i++) {
+                emit("Network.requestWillBeSent", {
+                    requestId: `r${i}`,
+                    request: { method: "GET", url: `https://example.com/${i}` },
+                    timestamp: i,
+                });
+            }
+            const last3 = collector.getNetworkEntries(3);
+            (0, vitest_1.expect)(last3).toHaveLength(3);
+            (0, vitest_1.expect)(last3[0].url).toBe("https://example.com/7");
+            (0, vitest_1.expect)(last3[2].url).toBe("https://example.com/9");
+        });
+        (0, vitest_1.it)("ignores response/finished events for unknown requestIds", async () => {
+            const { collector, emit } = await setup();
+            // These should not throw or create entries
+            emit("Network.responseReceived", {
+                requestId: "unknown",
+                response: { status: 200, statusText: "OK" },
+                timestamp: 1,
+            });
+            emit("Network.loadingFinished", {
+                requestId: "unknown",
+                encodedDataLength: 100,
+                timestamp: 2,
+            });
+            emit("Network.loadingFailed", {
+                requestId: "unknown",
+                errorText: "error",
+                timestamp: 3,
+            });
+            (0, vitest_1.expect)(collector.getNetworkEntries()).toHaveLength(0);
+        });
+    });
+    /* ── Network buffer eviction ────────────────────────────────────── */
+    (0, vitest_1.describe)("network buffer eviction", () => {
+        (0, vitest_1.it)("enforces max buffer size of 500, evicting oldest entries", async () => {
+            const { collector, emit } = await setup();
+            for (let i = 0; i < 520; i++) {
+                emit("Network.requestWillBeSent", {
+                    requestId: `r${i}`,
+                    request: { method: "GET", url: `https://example.com/${i}` },
+                    timestamp: i,
+                });
+            }
+            const entries = collector.getNetworkEntries();
+            (0, vitest_1.expect)(entries).toHaveLength(500);
+            // Oldest 20 entries should be evicted
+            (0, vitest_1.expect)(entries[0].url).toBe("https://example.com/20");
+            (0, vitest_1.expect)(entries[499].url).toBe("https://example.com/519");
+        });
+    });
+    /* ── Filter by level ────────────────────────────────────────────── */
+    (0, vitest_1.describe)("filtering console logs by level", () => {
+        (0, vitest_1.it)("stores different levels and allows external filtering", async () => {
+            const { collector, emit } = await setup();
+            emit("Runtime.consoleAPICalled", {
+                type: "log",
+                args: [{ value: "info msg" }],
+                timestamp: 1,
+            });
+            emit("Runtime.consoleAPICalled", {
+                type: "warn",
+                args: [{ value: "warn msg" }],
+                timestamp: 2,
+            });
+            emit("Runtime.consoleAPICalled", {
+                type: "error",
+                args: [{ value: "error msg" }],
+                timestamp: 3,
+            });
+            const all = collector.getConsoleLogs();
+            (0, vitest_1.expect)(all).toHaveLength(3);
+            // Filter externally (as the tool chrome_get_console_logs does)
+            const errors = all.filter((e) => e.level === "error");
+            (0, vitest_1.expect)(errors).toHaveLength(1);
+            (0, vitest_1.expect)(errors[0].text).toBe("error msg");
+            const warnings = all.filter((e) => e.level === "warn");
+            (0, vitest_1.expect)(warnings).toHaveLength(1);
+            (0, vitest_1.expect)(warnings[0].text).toBe("warn msg");
+            const logs = all.filter((e) => e.level === "log");
+            (0, vitest_1.expect)(logs).toHaveLength(1);
+            (0, vitest_1.expect)(logs[0].text).toBe("info msg");
+        });
+    });
+    /* ── enableDomains idempotency ──────────────────────────────────── */
+    (0, vitest_1.describe)("enableDomains", () => {
+        (0, vitest_1.it)("sends Runtime.enable, Network.enable, Page.enable", async () => {
+            const collector = new chrome_tools_js_1.CdpEventCollector();
+            const { bridge } = createMockBridge();
+            await collector.enableDomains(bridge);
+            (0, vitest_1.expect)(bridge.send).toHaveBeenCalledWith("Runtime.enable");
+            (0, vitest_1.expect)(bridge.send).toHaveBeenCalledWith("Network.enable");
+            (0, vitest_1.expect)(bridge.send).toHaveBeenCalledWith("Page.enable");
+        });
+        (0, vitest_1.it)("only enables domains once (idempotent)", async () => {
+            const collector = new chrome_tools_js_1.CdpEventCollector();
+            const { bridge } = createMockBridge();
+            await collector.enableDomains(bridge);
+            await collector.enableDomains(bridge);
+            // send should have been called exactly 3 times (Runtime, Network, Page)
+            (0, vitest_1.expect)(bridge.send).toHaveBeenCalledTimes(3);
+        });
+    });
+    /* ── Fresh instance (clear equivalent) ──────────────────────────── */
+    (0, vitest_1.describe)("reset / clear equivalent", () => {
+        (0, vitest_1.it)("a new CdpEventCollector instance starts with empty buffers", () => {
+            const collector = new chrome_tools_js_1.CdpEventCollector();
+            (0, vitest_1.expect)(collector.getConsoleLogs()).toHaveLength(0);
+            (0, vitest_1.expect)(collector.getNetworkEntries()).toHaveLength(0);
+        });
+        (0, vitest_1.it)("creating a new instance effectively clears all state", async () => {
+            const { collector, emit } = await setup();
+            emit("Runtime.consoleAPICalled", {
+                type: "log",
+                args: [{ value: "test" }],
+                timestamp: 1,
+            });
+            emit("Network.requestWillBeSent", {
+                requestId: "r1",
+                request: { method: "GET", url: "https://example.com" },
+                timestamp: 1,
+            });
+            (0, vitest_1.expect)(collector.getConsoleLogs()).toHaveLength(1);
+            (0, vitest_1.expect)(collector.getNetworkEntries()).toHaveLength(1);
+            // "Reset" by creating a new collector
+            const freshCollector = new chrome_tools_js_1.CdpEventCollector();
+            (0, vitest_1.expect)(freshCollector.getConsoleLogs()).toHaveLength(0);
+            (0, vitest_1.expect)(freshCollector.getNetworkEntries()).toHaveLength(0);
+        });
+    });
+    /* ── Rapid concurrent events ────────────────────────────────────── */
+    (0, vitest_1.describe)("rapid concurrent events", () => {
+        (0, vitest_1.it)("handles many console and network events fired in rapid succession", async () => {
+            const { collector, emit } = await setup();
+            // Fire 200 console + 200 network events synchronously
+            for (let i = 0; i < 200; i++) {
+                emit("Runtime.consoleAPICalled", {
+                    type: i % 3 === 0 ? "error" : i % 3 === 1 ? "warn" : "log",
+                    args: [{ value: `rapid-${i}` }],
+                    timestamp: i,
+                });
+                emit("Network.requestWillBeSent", {
+                    requestId: `rapid-r${i}`,
+                    request: { method: "GET", url: `https://example.com/rapid/${i}` },
+                    timestamp: i,
+                });
+            }
+            (0, vitest_1.expect)(collector.getConsoleLogs()).toHaveLength(200);
+            (0, vitest_1.expect)(collector.getNetworkEntries()).toHaveLength(200);
+        });
+        (0, vitest_1.it)("handles interleaved request/response events correctly", async () => {
+            const { collector, emit } = await setup();
+            // Start multiple requests
+            for (let i = 0; i < 50; i++) {
+                emit("Network.requestWillBeSent", {
+                    requestId: `req-${i}`,
+                    request: { method: "GET", url: `https://example.com/${i}` },
+                    timestamp: i * 0.1,
+                });
+            }
+            // Responses arrive in a different order
+            for (let i = 49; i >= 0; i--) {
+                emit("Network.responseReceived", {
+                    requestId: `req-${i}`,
+                    response: { status: 200, statusText: "OK" },
+                    timestamp: 10 + i * 0.1,
+                });
+            }
+            const entries = collector.getNetworkEntries();
+            (0, vitest_1.expect)(entries).toHaveLength(50);
+            // All should have status populated
+            for (const entry of entries) {
+                (0, vitest_1.expect)(entry.status).toBe(200);
+            }
+        });
+    });
+    /* ── Edge cases ─────────────────────────────────────────────────── */
+    (0, vitest_1.describe)("edge cases", () => {
+        (0, vitest_1.it)("handles console entry with no args", async () => {
+            const { collector, emit } = await setup();
+            emit("Runtime.consoleAPICalled", {
+                type: "log",
+                timestamp: 1000,
+                // no args field
+            });
+            const logs = collector.getConsoleLogs();
+            (0, vitest_1.expect)(logs).toHaveLength(1);
+            (0, vitest_1.expect)(logs[0].text).toBe("");
+        });
+        (0, vitest_1.it)("handles console entry with empty args array", async () => {
+            const { collector, emit } = await setup();
+            emit("Runtime.consoleAPICalled", {
+                type: "log",
+                args: [],
+                timestamp: 1000,
+            });
+            const logs = collector.getConsoleLogs();
+            (0, vitest_1.expect)(logs).toHaveLength(1);
+            (0, vitest_1.expect)(logs[0].text).toBe("");
+        });
+        (0, vitest_1.it)("uses Date.now() fallback when timestamp is missing", async () => {
+            const { collector, emit } = await setup();
+            const before = Date.now();
+            emit("Runtime.consoleAPICalled", {
+                type: "log",
+                args: [{ value: "no-ts" }],
+                // no timestamp
+            });
+            const after = Date.now();
+            const ts = collector.getConsoleLogs()[0].timestamp;
+            (0, vitest_1.expect)(ts).toBeGreaterThanOrEqual(before);
+            (0, vitest_1.expect)(ts).toBeLessThanOrEqual(after);
+        });
+        (0, vitest_1.it)("uses description when value is undefined in args", async () => {
+            const { collector, emit } = await setup();
+            emit("Runtime.consoleAPICalled", {
+                type: "log",
+                args: [{ description: "Promise { <pending> }" }],
+                timestamp: 1,
+            });
+            (0, vitest_1.expect)(collector.getConsoleLogs()[0].text).toBe("Promise { <pending> }");
+        });
+    });
+});
+//# sourceMappingURL=chrome-tools.test.js.map

package/dist/transport/cdp-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdp-bridge.d.ts","sourceRoot":"","sources":["../../src/transport/cdp-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAUH,KAAK,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;AAE9D,qBAAa,SAAS;IACpB,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAqC;IACrE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqC;IACpE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,MAAM;IAI1B;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,IAAI;IAMpD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAwCjC;;OAEG;IACG,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IAwB9E;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC;IAStC;;OAEG;IACH,UAAU,IAAI,IAAI;IAOlB,WAAW,IAAI,OAAO;IAItB,OAAO,CAAC,aAAa;IA0CrB,OAAO,CAAC,gBAAgB;CAOzB"}

package/dist/transport/cdp-bridge.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * CdpBridge — WebSocket bridge to the SensAI Chrome Extension.
+ *
+ * The extension runs a WebSocket server that proxies CDP commands
+ * through chrome.debugger API. This bridge connects to that server
+ * and provides a simple request/response API.
+ *
+ * Protocol: JSON-RPC 2.0 over WebSocket (same as Android agent protocol).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdpBridge = void 0;
+const ws_1 = __importDefault(require("ws"));
+class CdpBridge {
+    ws = null;
+    requestId = 0;
+    pendingRequests = new Map();
+    eventListeners = new Map();
+    wsPort;
+    connected = false;
+    constructor(wsPort) {
+        this.wsPort = wsPort;
+    }
+    /**
+     * Register a handler for a CDP event (e.g., "Runtime.consoleAPICalled").
+     */
+    onEvent(method, handler) {
+        const handlers = this.eventListeners.get(method) ?? [];
+        handlers.push(handler);
+        this.eventListeners.set(method, handlers);
+    }
+    /**
+     * Connect to the Chrome Extension's WebSocket server.
+     */
+    async connect() {
+        return new Promise((resolve) => {
+            try {
+                this.ws = new ws_1.default(`ws://localhost:${this.wsPort}`);
+                const connectionTimeout = setTimeout(() => {
+                    this.ws?.close();
+                    this.connected = false;
+                    resolve(false);
+                }, 5000);
+                this.ws.on("open", () => {
+                    clearTimeout(connectionTimeout);
+                    this.connected = true;
+                    process.stderr.write(`[sensai:chrome] Connected to extension on port ${this.wsPort}\n`);
+                    resolve(true);
+                });
+                this.ws.on("message", (data) => {
+                    this.handleMessage(data.toString());
+                });
+                this.ws.on("close", () => {
+                    this.connected = false;
+                    this.rejectAllPending("WebSocket connection closed");
+                    process.stderr.write("[sensai:chrome] Extension disconnected\n");
+                });
+                this.ws.on("error", () => {
+                    clearTimeout(connectionTimeout);
+                    this.connected = false;
+                    resolve(false);
+                });
+            }
+            catch {
+                this.connected = false;
+                resolve(false);
+            }
+        });
+    }
+    /**
+     * Send a CDP command through the extension and wait for response.
+     */
+    async send(method, params) {
+        if (!this.ws || !this.connected) {
+            throw new Error("Not connected to Chrome Extension");
+        }
+        const id = ++this.requestId;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`CDP request timed out: ${method}`));
+            }, 30_000);
+            this.pendingRequests.set(id, { resolve, reject, timeout });
+            this.ws.send(JSON.stringify({
+                jsonrpc: "2.0",
+                id,
+                method,
+                params: params ?? {},
+            }));
+        });
+    }
+    /**
+     * Get the current tab URL.
+     */
+    async getCurrentUrl() {
+        try {
+            const result = await this.send("getTabInfo");
+            return result.url ?? "";
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Disconnect from the extension.
+     */
+    disconnect() {
+        this.rejectAllPending("Shutting down");
+        this.ws?.close();
+        this.ws = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    handleMessage(raw) {
+        try {
+            const msg = JSON.parse(raw);
+            // CDP event (no id, has method) — dispatch to listeners
+            if (!msg.id && msg.method) {
+                const handlers = this.eventListeners.get(msg.method);
+                if (handlers) {
+                    for (const handler of handlers) {
+                        try {
+                            handler(msg.params ?? {});
+                        }
+                        catch {
+                            // event handler error should not break the bridge
+                        }
+                    }
+                }
+                return;
+            }
+            // CDP response (has id)
+            if (msg.id && this.pendingRequests.has(msg.id)) {
+                const pending = this.pendingRequests.get(msg.id);
+                this.pendingRequests.delete(msg.id);
+                clearTimeout(pending.timeout);
+                if (msg.error) {
+                    pending.reject(new Error(msg.error.message));
+                }
+                else {
+                    pending.resolve(msg.result);
+                }
+            }
+        }
+        catch {
+            process.stderr.write(`[sensai:chrome] Failed to parse message: ${raw.slice(0, 200)}\n`);
+        }
+    }
+    rejectAllPending(reason) {
+        for (const [id, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error(reason));
+            this.pendingRequests.delete(id);
+        }
+    }
+}
+exports.CdpBridge = CdpBridge;
+//# sourceMappingURL=cdp-bridge.js.map

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@sensaiorg/adapter-chrome",
+  "version": "0.1.0",
+  "description": "SensAI Chrome adapter — debug web apps via Chrome DevTools Protocol",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rm -rf dist .tsbuildinfo"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@sensaiorg/core": "0.1.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.0",
+    "typescript": "^5.7.0",
+    "zod": "^3.24.0"
+  }
+}