@hanzo/browser-extension 1.7.2

package/dist/browser-extension/cdp-bridge-server.js

@@ -0,0 +1,444 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cdp-bridge-server.ts
+var cdp_bridge_server_exports = {};
+__export(cdp_bridge_server_exports, {
+  CDPBridgeServer: () => CDPBridgeServer
+});
+module.exports = __toCommonJS(cdp_bridge_server_exports);
+var import_ws = require("ws");
+var readline = __toESM(require("readline"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var CDPBridgeServer = class {
+  constructor(port = 9223) {
+    this.clients = /* @__PURE__ */ new Map();
+    this.pendingCommands = /* @__PURE__ */ new Map();
+    this.commandId = 0;
+    this.httpPort = port;
+    this.wss = new import_ws.WebSocketServer({ port, path: "/cdp" });
+    this.wss.on("connection", (ws) => {
+      console.log("[hanzo.browser] Extension connected");
+      ws.on("message", (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          this.handleMessage(ws, message);
+        } catch (error) {
+          console.error("[hanzo.browser] Error:", error.message);
+        }
+      });
+      ws.on("close", () => {
+        console.log("[hanzo.browser] Extension disconnected");
+        this.clients.delete(ws);
+      });
+      ws.on("error", (error) => {
+        console.error("[hanzo.browser] WebSocket error:", error);
+      });
+    });
+    console.log(`[hanzo.browser] Server listening on ws://localhost:${port}/cdp`);
+  }
+  handleMessage(ws, message) {
+    var _a;
+    if (message.type === "register") {
+      this.clients.set(ws, {
+        ws,
+        capabilities: message.capabilities || [],
+        browser: message.browser || "unknown"
+      });
+      console.log(`[hanzo.browser] Registered ${message.browser || "unknown"}:`, (_a = message.capabilities) == null ? void 0 : _a.join(", "));
+      return;
+    }
+    if (message.type === "config") {
+      this.saveConfig(message.key, message.value);
+      return;
+    }
+    if (message.id !== void 0) {
+      const pending = this.pendingCommands.get(message.id);
+      if (pending) {
+        if (message.error) {
+          pending.reject(new Error(message.error.message));
+        } else {
+          pending.resolve(message.result);
+        }
+        this.pendingCommands.delete(message.id);
+      }
+      return;
+    }
+    if (message.type === "event") {
+      console.log(`[hanzo.browser] Event: ${message.method}`);
+    }
+  }
+  /** Save a config value to ~/.hanzo/extension/config.json */
+  saveConfig(key, value) {
+    const configDir = path.join(
+      process.env.HOME || process.env.USERPROFILE || ".",
+      ".hanzo",
+      "extension"
+    );
+    const configPath = path.join(configDir, "config.json");
+    try {
+      fs.mkdirSync(configDir, { recursive: true });
+      let config = {};
+      if (fs.existsSync(configPath)) {
+        config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      }
+      config[key] = value;
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+      console.log(`[hanzo.browser] Config saved: ${key} = ${JSON.stringify(value)}`);
+    } catch (error) {
+      console.error(`[hanzo.browser] Failed to save config: ${error.message}`);
+    }
+  }
+  /** Get connected browser names */
+  getConnectedBrowsers() {
+    return Array.from(this.clients.values()).map((c) => c.browser || "unknown").filter((b) => b !== "unknown");
+  }
+  async sendRaw(method, params) {
+    const client = Array.from(this.clients.values())[0];
+    if (!client) {
+      throw new Error("No browser extension connected");
+    }
+    const id = ++this.commandId;
+    return new Promise((resolve, reject) => {
+      this.pendingCommands.set(id, { resolve, reject });
+      client.ws.send(JSON.stringify({ id, method, params }));
+      setTimeout(() => {
+        if (this.pendingCommands.has(id)) {
+          this.pendingCommands.delete(id);
+          reject(new Error("Command timeout"));
+        }
+      }, 3e4);
+    });
+  }
+  /**
+   * Unified hanzo.browser interface - matches mcp__hanzo__browser pattern
+   */
+  async browser(params) {
+    const { action, ...rest } = params;
+    switch (action) {
+      // Navigation
+      case "navigate":
+        return this.sendRaw("Page.navigate", { url: rest.url });
+      case "navigate_back":
+      case "go_back":
+        return this.sendRaw("Page.goBack");
+      case "navigate_forward":
+      case "go_forward":
+        return this.sendRaw("Page.goForward");
+      case "reload":
+        return this.sendRaw("Page.reload");
+      case "url":
+        return this.sendRaw("hanzo.url");
+      case "title":
+        return this.sendRaw("hanzo.title");
+      case "tab_info":
+        return this.sendRaw("hanzo.tabInfo");
+      case "content":
+        return this.sendRaw("Runtime.evaluate", {
+          expression: "document.documentElement.outerHTML",
+          returnByValue: true
+        });
+      // Screenshots
+      case "screenshot":
+        const screenshot = await this.sendRaw("hanzo.screenshot", {
+          format: rest.format || "png",
+          fullPage: rest.fullPage
+        });
+        if (rest.filename && screenshot.data) {
+          const buffer = Buffer.from(screenshot.data, "base64");
+          fs.writeFileSync(rest.filename, buffer);
+          return { saved: rest.filename, bytes: buffer.length };
+        }
+        return screenshot;
+      case "snapshot":
+        return this.sendRaw("Accessibility.getFullAXTree");
+      // Input - Click
+      case "click":
+        return this.sendRaw("hanzo.click", {
+          selector: rest.selector || rest.ref
+        });
+      case "dblclick":
+      case "double_click":
+        return this.sendRaw("hanzo.dblclick", {
+          selector: rest.selector || rest.ref
+        });
+      case "hover":
+        return this.sendRaw("hanzo.hover", {
+          selector: rest.selector || rest.ref
+        });
+      // Input - Type
+      case "type":
+        return this.sendRaw("hanzo.type", {
+          selector: rest.selector || rest.ref,
+          text: rest.text
+        });
+      case "fill":
+        return this.sendRaw("hanzo.fill", {
+          selector: rest.selector || rest.ref,
+          value: rest.value || rest.text
+        });
+      case "clear":
+        return this.sendRaw("hanzo.clear", {
+          selector: rest.selector || rest.ref
+        });
+      case "press_key":
+      case "press":
+        return this.sendRaw("Input.dispatchKeyEvent", {
+          type: "keyDown",
+          key: rest.key
+        });
+      // Forms
+      case "select_option":
+        return this.sendRaw("hanzo.select", {
+          selector: rest.selector || rest.ref,
+          value: rest.value
+        });
+      case "check":
+        return this.sendRaw("hanzo.check", {
+          selector: rest.selector || rest.ref
+        });
+      case "uncheck":
+        return this.sendRaw("hanzo.uncheck", {
+          selector: rest.selector || rest.ref
+        });
+      // Evaluate
+      case "evaluate":
+        return this.sendRaw("Runtime.evaluate", {
+          expression: rest.code || rest.function || rest.expression,
+          returnByValue: true
+        });
+      // Wait
+      case "wait":
+        await new Promise((resolve) => setTimeout(resolve, (rest.timeout || 1) * 1e3));
+        return { waited: rest.timeout || 1 };
+      case "wait_for_load":
+        return this.sendRaw("Page.waitForLoadState", {
+          state: rest.state || "load"
+        });
+      // Tabs
+      case "tabs":
+      case "list_tabs":
+        return this.sendRaw("Target.getTargets");
+      case "new_tab":
+        return this.sendRaw("Target.createTarget", { url: rest.url || "about:blank" });
+      case "close_tab":
+        return this.sendRaw("Target.closeTarget", { targetId: rest.tabId });
+      case "select_tab":
+        return this.sendRaw("Target.activateTarget", { targetId: rest.tabId });
+      // Console/Network
+      case "console_messages":
+      case "console":
+        return this.sendRaw("Console.getMessages");
+      case "network_requests":
+        return this.sendRaw("Network.getResponseBodies");
+      // Status
+      case "status":
+        return {
+          connected: this.clients.size > 0,
+          clients: this.clients.size,
+          port: this.httpPort
+        };
+      default:
+        return this.sendRaw(action, rest);
+    }
+  }
+  isConnected() {
+    return this.clients.size > 0;
+  }
+  close() {
+    this.wss.close();
+  }
+};
+async function startJSONRPCServer(bridgeServer) {
+  const http = require("http");
+  const httpServer = http.createServer(async (req, res) => {
+    if (req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      req.on("end", async () => {
+        try {
+          const request = JSON.parse(body);
+          const result = await bridgeServer.browser(request.params || request);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ result }));
+        } catch (error) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: error.message }));
+        }
+      });
+    } else {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        service: "hanzo.browser",
+        connected: bridgeServer.isConnected(),
+        browsers: bridgeServer.getConnectedBrowsers(),
+        actions: [
+          "navigate",
+          "navigate_back",
+          "reload",
+          "url",
+          "title",
+          "content",
+          "screenshot",
+          "snapshot",
+          "click",
+          "dblclick",
+          "hover",
+          "type",
+          "fill",
+          "clear",
+          "press_key",
+          "select_option",
+          "check",
+          "uncheck",
+          "evaluate",
+          "wait",
+          "wait_for_load",
+          "tabs",
+          "new_tab",
+          "close_tab",
+          "select_tab",
+          "console",
+          "network_requests",
+          "takeover.start",
+          "takeover.end",
+          "takeover.cursor",
+          "status"
+        ]
+      }));
+    }
+  });
+  httpServer.listen(9224, () => {
+    console.log("[hanzo.browser] HTTP API at http://localhost:9224");
+  });
+}
+async function main() {
+  const port = parseInt(process.env.CDP_PORT || "9223");
+  const server = new CDPBridgeServer(port);
+  startJSONRPCServer(server);
+  console.log("\n[hanzo.browser] Commands:");
+  console.log("  navigate <url>      - Go to URL");
+  console.log("  screenshot [file]   - Capture screen");
+  console.log("  click <selector>    - Click element");
+  console.log("  type <sel> <text>   - Type into element");
+  console.log("  eval <js>           - Run JavaScript");
+  console.log("  tabs                - List all tabs");
+  console.log("  status              - Connection status");
+  console.log("  quit                - Exit\n");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const prompt = () => {
+    rl.question("hanzo.browser> ", async (line) => {
+      var _a, _b, _c, _d;
+      const parts = line.trim().split(" ");
+      const action = parts[0];
+      const args = parts.slice(1);
+      if (!action) {
+        prompt();
+        return;
+      }
+      try {
+        let result;
+        switch (action) {
+          case "quit":
+          case "exit":
+            server.close();
+            rl.close();
+            process.exit(0);
+          case "navigate":
+            result = await server.browser({ action: "navigate", url: args[0] });
+            console.log("Navigated to:", args[0]);
+            break;
+          case "screenshot":
+            result = await server.browser({
+              action: "screenshot",
+              filename: args[0] || `screenshot-${Date.now()}.png`
+            });
+            console.log("Screenshot:", result);
+            break;
+          case "click":
+            result = await server.browser({ action: "click", selector: args[0] });
+            console.log("Clicked:", args[0]);
+            break;
+          case "type":
+            result = await server.browser({
+              action: "type",
+              selector: args[0],
+              text: args.slice(1).join(" ")
+            });
+            console.log("Typed into:", args[0]);
+            break;
+          case "eval":
+            result = await server.browser({
+              action: "evaluate",
+              expression: args.join(" ")
+            });
+            console.log("Result:", (_a = result == null ? void 0 : result.result) == null ? void 0 : _a.value);
+            break;
+          case "tabs":
+            result = await server.browser({ action: "tabs" });
+            console.log("Tabs:", (_b = result == null ? void 0 : result.targetInfos) == null ? void 0 : _b.map((t) => t.title).join(", "));
+            break;
+          case "status":
+            result = await server.browser({ action: "status" });
+            console.log("Status:", result);
+            break;
+          case "url":
+            result = await server.browser({ action: "url" });
+            console.log("URL:", (_c = result == null ? void 0 : result.result) == null ? void 0 : _c.value);
+            break;
+          case "title":
+            result = await server.browser({ action: "title" });
+            console.log("Title:", (_d = result == null ? void 0 : result.result) == null ? void 0 : _d.value);
+            break;
+          default:
+            result = await server.browser({ action, ...Object.fromEntries(
+              args.map((a, i) => [i === 0 ? "selector" : `arg${i}`, a])
+            ) });
+            console.log("Result:", result);
+        }
+      } catch (error) {
+        console.error("Error:", error.message);
+      }
+      prompt();
+    });
+  };
+  prompt();
+}
+if (require.main === module) {
+  main();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CDPBridgeServer
+});