@hanzo/browser-extension 1.7.6 → 1.9.33

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

@@ -1,444 +0,0 @@
-#!/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
-});