@hanzo/browser-extension 1.7.6 → 1.9.31

package/.github/workflows/docs.yml

@@ -1,44 +0,0 @@
-name: Deploy Docs
-
-on:
-  push:
-    branches: [main]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-
-concurrency:
-  group: pages
-  cancel-in-progress: false
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup Pages
-        uses: actions/configure-pages@v4
-
-      - name: Build with Jekyll
-        uses: actions/jekyll-build-pages@v1
-        with:
-          source: ./docs
-          destination: ./_site
-
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
-
-  deploy:
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    needs: build
-    steps:
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4

package/.github/workflows/release.yml

@@ -1,55 +0,0 @@
-name: Release
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-permissions:
-  contents: write
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          cache: 'npm'
-
-      - name: Install dependencies
-        run: npm ci || npm install
-
-      - name: Build extension
-        run: npm run build
-
-      - name: Get version
-        id: version
-        run: echo "version=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
-
-      - name: Package Chrome extension
-        run: |
-          cd dist
-          zip -r ../hanzo-browser-extension-chrome-${{ steps.version.outputs.version }}.zip .
-
-      - name: Package Firefox extension
-        run: |
-          # Copy Firefox manifest if exists
-          if [ -f src/manifest-firefox.json ]; then
-            cp src/manifest-firefox.json dist/manifest.json
-          fi
-          cd dist
-          zip -r ../hanzo-browser-extension-firefox-${{ steps.version.outputs.version }}.zip .
-
-      - name: Create GitHub Release
-        uses: softprops/action-gh-release@v2
-        with:
-          files: |
-            hanzo-browser-extension-chrome-*.zip
-            hanzo-browser-extension-firefox-*.zip
-          generate_release_notes: true
-          draft: false
-          prerelease: ${{ contains(github.ref, 'alpha') || contains(github.ref, 'beta') || contains(github.ref, 'rc') }}

package/README.md

@@ -1,126 +0,0 @@
-# Hanzo AI Browser Extension
-
-AI-powered browser extension for Chrome, Firefox, Edge, and Safari.
-
-[![Chrome](https://img.shields.io/badge/Chrome-4285F4?style=for-the-badge&logo=googlechrome&logoColor=white)](https://chrome.google.com/webstore)
-[![Firefox](https://img.shields.io/badge/Firefox-FF7139?style=for-the-badge&logo=firefox&logoColor=white)](https://addons.mozilla.org)
-[![Edge](https://img.shields.io/badge/Edge-0078D7?style=for-the-badge&logo=microsoftedge&logoColor=white)](https://microsoftedge.microsoft.com/addons)
-[![Safari](https://img.shields.io/badge/Safari-000000?style=for-the-badge&logo=safari&logoColor=white)](https://apps.apple.com)
-
-## Features
-
-- **AI Chat Sidebar**: Chat with Claude, GPT-4, Gemini, and more
-- **Page Analysis**: Summarize, explain, and query any webpage
-- **Selection Actions**: Right-click menu for AI operations on selected text
-- **MCP Integration**: Access 260+ MCP tools from your browser
-- **Cloud Sync**: Sync conversations and settings via cloud.hanzo.ai
-
-## Installation
-
-### Chrome / Edge / Brave
-
-1. Download the latest release from [Releases](https://github.com/hanzoai/browser-extension/releases)
-2. Open `chrome://extensions` (or `edge://extensions`)
-3. Enable "Developer mode"
-4. Click "Load unpacked" and select the `dist` folder
-
-### Firefox
-
-1. Download the latest release
-2. Open `about:debugging`
-3. Click "This Firefox" → "Load Temporary Add-on"
-4. Select `manifest.json`
-
-### Safari
-
-1. Enable developer mode in Safari preferences
-2. Download the macOS app version from [Releases](https://github.com/hanzoai/browser-extension/releases)
-3. Open the app and enable the extension in Safari preferences
-
-## Development
-
-```bash
-# Install dependencies
-npm install
-
-# Build extension
-npm run build
-
-# Watch mode for development
-npm run watch
-
-# Run tests
-npm test
-```
-
-## Building for Production
-
-```bash
-# Build for all browsers
-npm run build
-
-# The dist/ folder contains the extension ready for loading
-```
-
-## Project Structure
-
-```
-browser-extension/
-├── src/
-│   ├── background/    # Service worker / background script
-│   ├── content/       # Content scripts injected into pages
-│   ├── popup/         # Extension popup UI
-│   ├── sidebar/       # AI chat sidebar
-│   └── shared/        # Shared utilities
-├── dist/              # Built extension
-├── manifest.json      # Extension manifest (MV3)
-├── package.json
-└── tsconfig.json
-```
-
-## Configuration
-
-### API Keys
-
-The extension uses your Hanzo AI account for API access. Login at:
-- [cloud.hanzo.ai](https://cloud.hanzo.ai) - Cloud dashboard
-- [iam.hanzo.ai](https://iam.hanzo.ai) - API key management
-
-Or set environment variables for direct provider access:
-- `ANTHROPIC_API_KEY` - Claude models
-- `OPENAI_API_KEY` - GPT models
-- `GOOGLE_API_KEY` - Gemini models
-
-### Permissions
-
-The extension requests minimal permissions:
-- `activeTab` - Access to current tab when activated
-- `storage` - Store settings and conversations locally
-- `contextMenus` - Right-click menu integration
-
-## Architecture
-
-```
-┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
-│ Content Script  │ ◄──► │ Background       │ ◄──► │ Hanzo API       │
-│ (Page Context)  │     │ (Service Worker) │     │ (api.hanzo.ai)  │
-└─────────────────┘     └──────────────────┘     └─────────────────┘
-         │                      │
-         │                      │
-         ▼                      ▼
-┌─────────────────┐     ┌──────────────────┐
-│ Popup / Sidebar │     │ MCP Bridge       │
-│ (React UI)      │     │ (WebSocket)      │
-└─────────────────┘     └──────────────────┘
-```
-
-## Related Projects
-
-- [ide-extension](https://github.com/hanzoai/ide-extension) - VS Code and JetBrains plugins
-- [hanzo-mcp](https://github.com/hanzoai/mcp) - Model Context Protocol tools
-- [hanzo.vim](https://github.com/hanzoai/hanzo.vim) - Vim/Neovim plugin
-- [hanzo.el](https://github.com/hanzoai/hanzo.el) - Emacs package
-
-## License
-
-MIT - See [LICENSE](LICENSE)

package/dist/browser-extension/ai-worker.js

@@ -1,30 +0,0 @@
-// AI Worker stub for browser extension
-// This is a Web Worker that handles AI inference tasks per-tab
-
-self.onmessage = function(event) {
-  const { type, tabId, modelName } = event.data;
-
-  switch (type) {
-    case 'init':
-      console.log(`[AI Worker] Initialized for tab ${tabId} with model ${modelName}`);
-      self.postMessage({ type: 'ready', tabId });
-      break;
-
-    case 'screenshot':
-      // Process screenshot for AI analysis (stub)
-      self.postMessage({ type: 'analysis', result: 'Screenshot received' });
-      break;
-
-    case 'contentMessage':
-      // Handle content script messages (stub)
-      self.postMessage({ type: 'contentResponse', response: { received: true } });
-      break;
-
-    case 'broadcast':
-      // Handle broadcast messages (stub)
-      break;
-
-    default:
-      console.warn('[AI Worker] Unknown message type:', type);
-  }
-};

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
-});