@sensaiorg/adapter-chrome 0.1.0

package/src/transport/cdp-bridge.ts

@@ -0,0 +1,187 @@
+/**
+ * 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).
+ */
+
+import WebSocket from "ws";
+
+interface PendingRequest {
+  resolve: (result: unknown) => void;
+  reject: (error: Error) => void;
+  timeout: ReturnType<typeof setTimeout>;
+}
+
+type EventHandler = (params: Record<string, unknown>) => void;
+
+export class CdpBridge {
+  private ws: WebSocket | null = null;
+  private requestId = 0;
+  private readonly pendingRequests = new Map<number, PendingRequest>();
+  private readonly eventListeners = new Map<string, EventHandler[]>();
+  private readonly wsPort: number;
+  private connected = false;
+
+  constructor(wsPort: number) {
+    this.wsPort = wsPort;
+  }
+
+  /**
+   * Register a handler for a CDP event (e.g., "Runtime.consoleAPICalled").
+   */
+  onEvent(method: string, handler: EventHandler): void {
+    const handlers = this.eventListeners.get(method) ?? [];
+    handlers.push(handler);
+    this.eventListeners.set(method, handlers);
+  }
+
+  /**
+   * Connect to the Chrome Extension's WebSocket server.
+   */
+  async connect(): Promise<boolean> {
+    return new Promise((resolve) => {
+      try {
+        this.ws = new WebSocket(`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: WebSocket.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: string, params?: Record<string, unknown>): Promise<unknown> {
+    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(): Promise<string> {
+    try {
+      const result = await this.send("getTabInfo") as { url?: string };
+      return result.url ?? "";
+    } catch {
+      return "";
+    }
+  }
+
+  /**
+   * Disconnect from the extension.
+   */
+  disconnect(): void {
+    this.rejectAllPending("Shutting down");
+    this.ws?.close();
+    this.ws = null;
+    this.connected = false;
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  private handleMessage(raw: string): void {
+    try {
+      const msg = JSON.parse(raw) as {
+        id?: number;
+        method?: string;
+        params?: Record<string, unknown>;
+        result?: unknown;
+        error?: { message: string };
+      };
+
+      // 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`);
+    }
+  }
+
+  private rejectAllPending(reason: string): void {
+    for (const [id, pending] of this.pendingRequests) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error(reason));
+      this.pendingRequests.delete(id);
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"],
+  "references": [
+    { "path": "../core" }
+  ]
+}