@hanzo/browser-extension 1.7.6 → 1.9.33

package/dist/browser-extension/background-firefox.js

@@ -1,875 +0,0 @@
-"use strict";
-(() => {
-  // src/auth.ts
-  function generateRandomString(length) {
-    const array = new Uint8Array(length);
-    crypto.getRandomValues(array);
-    return Array.from(array, (b) => b.toString(36).padStart(2, "0")).join("").slice(0, length);
-  }
-  async function sha256(plain) {
-    const encoder = new TextEncoder();
-    return crypto.subtle.digest("SHA-256", encoder.encode(plain));
-  }
-  function base64UrlEncode(buffer) {
-    const bytes = new Uint8Array(buffer);
-    let binary = "";
-    for (const byte of bytes) {
-      binary += String.fromCharCode(byte);
-    }
-    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-  }
-  async function generatePkceChallenge() {
-    const codeVerifier = generateRandomString(64);
-    const hash = await sha256(codeVerifier);
-    const codeChallenge = base64UrlEncode(hash);
-    return { codeVerifier, codeChallenge };
-  }
-  function generateState() {
-    return generateRandomString(32);
-  }
-  var IAM_LOGIN = "https://hanzo.id";
-  var IAM_API = "https://iam.hanzo.ai";
-  var CLIENT_ID = "app-hanzo";
-  var SCOPES = "openid profile email";
-  function getRedirectUri() {
-    return "https://hanzo.ai/callback";
-  }
-  var STORAGE_KEYS = {
-    accessToken: "hanzo_iam_access_token",
-    refreshToken: "hanzo_iam_refresh_token",
-    idToken: "hanzo_iam_id_token",
-    expiresAt: "hanzo_iam_expires_at",
-    user: "hanzo_iam_user"
-  };
-  async function storeTokens(tokens) {
-    const data = {
-      [STORAGE_KEYS.accessToken]: tokens.access_token
-    };
-    if (tokens.refresh_token) data[STORAGE_KEYS.refreshToken] = tokens.refresh_token;
-    if (tokens.id_token) data[STORAGE_KEYS.idToken] = tokens.id_token;
-    if (tokens.expires_in) {
-      data[STORAGE_KEYS.expiresAt] = Date.now() + tokens.expires_in * 1e3;
-    }
-    return chrome.storage.local.set(data);
-  }
-  async function getStoredTokens() {
-    return new Promise((resolve) => {
-      chrome.storage.local.get(
-        [STORAGE_KEYS.accessToken, STORAGE_KEYS.refreshToken, STORAGE_KEYS.expiresAt],
-        (result) => {
-          resolve({
-            accessToken: result[STORAGE_KEYS.accessToken] || null,
-            refreshToken: result[STORAGE_KEYS.refreshToken] || null,
-            expiresAt: result[STORAGE_KEYS.expiresAt] || null
-          });
-        }
-      );
-    });
-  }
-  async function login() {
-    const { codeVerifier, codeChallenge } = await generatePkceChallenge();
-    const state = generateState();
-    const redirectUri = getRedirectUri();
-    const authorizeUrl = new URL(`${IAM_LOGIN}/login/oauth/authorize`);
-    authorizeUrl.searchParams.set("client_id", CLIENT_ID);
-    authorizeUrl.searchParams.set("response_type", "code");
-    authorizeUrl.searchParams.set("redirect_uri", redirectUri);
-    authorizeUrl.searchParams.set("code_challenge", codeChallenge);
-    authorizeUrl.searchParams.set("code_challenge_method", "S256");
-    authorizeUrl.searchParams.set("scope", SCOPES);
-    authorizeUrl.searchParams.set("state", state);
-    const callbackUrl = await openAuthTab(authorizeUrl.toString(), redirectUri);
-    const url = new URL(callbackUrl);
-    const returnedState = url.searchParams.get("state");
-    if (returnedState !== state) throw new Error("State mismatch \u2014 possible CSRF");
-    const code = url.searchParams.get("code");
-    const directToken = url.searchParams.get("access_token");
-    if (directToken) {
-      const tokens = {
-        access_token: directToken,
-        refresh_token: url.searchParams.get("refresh_token") || void 0,
-        token_type: "Bearer"
-      };
-      await storeTokens(tokens);
-    } else if (code) {
-      const tokenResponse = await fetch(`${IAM_API}/api/login/oauth/access_token`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          grant_type: "authorization_code",
-          client_id: CLIENT_ID,
-          code,
-          redirect_uri: redirectUri,
-          code_verifier: codeVerifier
-        })
-      });
-      if (!tokenResponse.ok) {
-        const errText = await tokenResponse.text();
-        throw new Error(`Token exchange failed: ${errText}`);
-      }
-      const tokens = await tokenResponse.json();
-      await storeTokens(tokens);
-    } else {
-      const error = url.searchParams.get("error_description") || url.searchParams.get("error") || "No authorization code or token";
-      throw new Error(error);
-    }
-    const { accessToken } = await getStoredTokens();
-    if (!accessToken) throw new Error("Login succeeded but no token was stored");
-    const user = await fetchUserInfo(accessToken);
-    await chrome.storage.local.set({ [STORAGE_KEYS.user]: user });
-    return user;
-  }
-  function openAuthTab(authorizeUrl, redirectUriPrefix) {
-    return new Promise((resolve, reject) => {
-      let authTabId;
-      const timeout = setTimeout(() => {
-        cleanup();
-        reject(new Error("Login timed out"));
-      }, 3e5);
-      function cleanup() {
-        clearTimeout(timeout);
-        chrome.tabs.onUpdated.removeListener(onTabUpdated);
-        chrome.tabs.onRemoved.removeListener(onTabRemoved);
-      }
-      function onTabUpdated(tabId, changeInfo) {
-        if (tabId !== authTabId || !changeInfo.url) return;
-        if (changeInfo.url.startsWith(redirectUriPrefix)) {
-          const callbackUrl = changeInfo.url;
-          cleanup();
-          chrome.tabs.remove(tabId).catch(() => {
-          });
-          resolve(callbackUrl);
-        }
-      }
-      function onTabRemoved(tabId) {
-        if (tabId !== authTabId) return;
-        cleanup();
-        reject(new Error("Login cancelled"));
-      }
-      chrome.tabs.onUpdated.addListener(onTabUpdated);
-      chrome.tabs.onRemoved.addListener(onTabRemoved);
-      chrome.tabs.create({ url: authorizeUrl }, (tab) => {
-        if (chrome.runtime.lastError || !tab?.id) {
-          cleanup();
-          reject(new Error(chrome.runtime.lastError?.message || "Failed to open login tab"));
-          return;
-        }
-        authTabId = tab.id;
-      });
-    });
-  }
-  async function logout() {
-    await chrome.storage.local.remove(Object.values(STORAGE_KEYS));
-  }
-  async function getValidAccessToken() {
-    const { accessToken, refreshToken, expiresAt } = await getStoredTokens();
-    if (!accessToken) return null;
-    if (expiresAt && Date.now() < expiresAt - 6e4) {
-      return accessToken;
-    }
-    if (refreshToken) {
-      try {
-        const refreshed = await refreshAccessToken(refreshToken);
-        return refreshed;
-      } catch {
-        await logout();
-        return null;
-      }
-    }
-    return accessToken;
-  }
-  async function refreshAccessToken(refreshToken) {
-    const response = await fetch(`${IAM_API}/api/login/oauth/access_token`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        grant_type: "refresh_token",
-        client_id: CLIENT_ID,
-        refresh_token: refreshToken
-      })
-    });
-    if (!response.ok) throw new Error("Token refresh failed");
-    const tokens = await response.json();
-    await storeTokens(tokens);
-    return tokens.access_token;
-  }
-  async function fetchUserInfo(accessToken) {
-    const response = await fetch(`${IAM_API}/api/userinfo`, {
-      headers: { Authorization: `Bearer ${accessToken}` }
-    });
-    if (!response.ok) throw new Error("Failed to fetch user info");
-    return response.json();
-  }
-  async function getUserInfo() {
-    return new Promise((resolve) => {
-      chrome.storage.local.get([STORAGE_KEYS.user], (result) => {
-        resolve(result[STORAGE_KEYS.user] || null);
-      });
-    });
-  }
-  async function isAuthenticated() {
-    const { accessToken } = await getStoredTokens();
-    return !!accessToken;
-  }
-  async function getAuthStatus() {
-    const [authenticated, user] = await Promise.all([
-      isAuthenticated(),
-      getUserInfo()
-    ]);
-    return { authenticated, user };
-  }
-
-  // src/chat-client.ts
-  var API_BASE = "https://api.hanzo.ai";
-  async function listModels(token) {
-    const response = await fetch(`${API_BASE}/v1/models`, {
-      headers: { Authorization: `Bearer ${token}` }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to list models: ${response.status}`);
-    }
-    const data = await response.json();
-    return data.data || data.models || data || [];
-  }
-  async function chatCompletion(token, options) {
-    const response = await fetch(`${API_BASE}/v1/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify(options)
-    });
-    if (!response.ok) {
-      const text = await response.text();
-      throw new Error(`Chat API error ${response.status}: ${text}`);
-    }
-    const data = await response.json();
-    return data.choices?.[0]?.message?.content || "";
-  }
-
-  // src/background-firefox.ts
-  var controlSession = {
-    active: false,
-    tabId: null,
-    task: null,
-    startedAt: null
-  };
-  var HanzoFirefoxExtension = class {
-    constructor() {
-      this.wsConnection = null;
-      this.cdpPort = 9223;
-      this.reconnectTimeout = 3e3;
-      console.log("[Hanzo] Firefox extension initializing...");
-      this.loadPort().then(() => this.connect());
-    }
-    async loadPort() {
-      try {
-        const result = await browser.storage.local.get(["cdpPort"]);
-        if (result.cdpPort) this.cdpPort = result.cdpPort;
-      } catch {
-      }
-    }
-    connect() {
-      const url = `ws://localhost:${this.cdpPort}/cdp`;
-      console.log(`[Hanzo] Connecting to ${url}`);
-      this.wsConnection = new WebSocket(url);
-      this.wsConnection.onopen = () => {
-        console.log("[Hanzo] WebSocket CONNECTED");
-        this.register();
-      };
-      this.wsConnection.onmessage = async (event) => {
-        try {
-          const message = JSON.parse(event.data);
-          console.log("[Hanzo] Received:", message.method || "response");
-          const response = await this.handleCommand(message);
-          this.send(response);
-        } catch (e) {
-          console.error("[Hanzo] Message handler error:", e);
-          this.send({ id: 0, error: { code: -1, message: String(e) } });
-        }
-      };
-      this.wsConnection.onerror = () => {
-      };
-      this.wsConnection.onclose = () => {
-        console.log("[Hanzo] Disconnected, reconnecting...");
-        setTimeout(() => this.connect(), this.reconnectTimeout);
-      };
-    }
-    isConnected() {
-      return this.wsConnection?.readyState === WebSocket.OPEN;
-    }
-    sendToWs(data) {
-      if (this.wsConnection?.readyState === WebSocket.OPEN) {
-        this.wsConnection.send(JSON.stringify(data));
-      }
-    }
-    register() {
-      this.sendToWs({
-        type: "register",
-        role: "cdp-provider",
-        capabilities: [
-          "navigate",
-          "screenshot",
-          "click",
-          "type",
-          "evaluate",
-          "tabs",
-          "fill",
-          "reload",
-          "goBack",
-          "goForward"
-        ]
-      });
-    }
-    send(data) {
-      this.sendToWs(data);
-    }
-    async handleCommand(message) {
-      const { id, method, params = {} } = message;
-      try {
-        const result = await this.executeMethod(method, params);
-        return { id, result };
-      } catch (e) {
-        return { id, error: { code: -1, message: String(e) } };
-      }
-    }
-    executeScriptWithTimeout(tabId, code, timeoutMs = 1e4) {
-      return Promise.race([
-        browser.tabs.executeScript(tabId, { code }),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("executeScript timeout")), timeoutMs)
-        )
-      ]);
-    }
-    async executeMethod(method, params) {
-      const [activeTab] = await browser.tabs.query({
-        active: true,
-        currentWindow: true
-      });
-      switch (method) {
-        case "Target.getTargets": {
-          const allTabs = await browser.tabs.query({});
-          return {
-            targetInfos: allTabs.map((tab) => ({
-              targetId: `tab-${tab.id}`,
-              type: "page",
-              title: tab.title || "",
-              url: tab.url || ""
-            }))
-          };
-        }
-        case "hanzo.url": {
-          if (activeTab) return { result: { value: activeTab.url || "" } };
-          throw new Error("No active tab");
-        }
-        case "hanzo.title": {
-          if (activeTab) return { result: { value: activeTab.title || "" } };
-          throw new Error("No active tab");
-        }
-        case "hanzo.tabInfo": {
-          if (activeTab) {
-            return {
-              result: {
-                value: {
-                  id: activeTab.id,
-                  url: activeTab.url,
-                  title: activeTab.title,
-                  status: activeTab.status,
-                  favIconUrl: activeTab.favIconUrl
-                }
-              }
-            };
-          }
-          throw new Error("No active tab");
-        }
-        case "Page.navigate": {
-          if (activeTab?.id) {
-            this.notifyOverlay(activeTab.id, "ai.control.status", { text: `Navigating to ${params.url}` });
-            await browser.tabs.update(activeTab.id, { url: params.url });
-            return { frameId: "main" };
-          }
-          throw new Error("No active tab");
-        }
-        case "Page.reload": {
-          if (activeTab?.id) {
-            await browser.tabs.reload(activeTab.id);
-            return { success: true };
-          }
-          throw new Error("No active tab");
-        }
-        case "Page.goBack": {
-          if (activeTab?.id) {
-            await browser.tabs.goBack(activeTab.id);
-            return { success: true };
-          }
-          throw new Error("No active tab");
-        }
-        case "Page.goForward": {
-          if (activeTab?.id) {
-            await browser.tabs.goForward(activeTab.id);
-            return { success: true };
-          }
-          throw new Error("No active tab");
-        }
-        case "Runtime.evaluate": {
-          if (activeTab?.id) {
-            const expression = params.expression;
-            const timeout = params.timeout || 1e4;
-            const results = await this.executeScriptWithTimeout(activeTab.id, expression, timeout);
-            return { result: { value: results[0] } };
-          }
-          throw new Error("No active tab");
-        }
-        case "Page.captureScreenshot":
-        case "hanzo.screenshot": {
-          const format = params.format || "jpeg";
-          const quality = params.quality || (format === "jpeg" ? 80 : void 0);
-          const opts = { format };
-          if (quality !== void 0) opts.quality = quality;
-          const dataUrl = await browser.tabs.captureVisibleTab(opts);
-          const base64 = dataUrl.replace(/^data:image\/\w+;base64,/, "");
-          return { data: base64 };
-        }
-        case "hanzo.click": {
-          if (activeTab?.id && params.selector) {
-            const selector = this.escapeSelector(params.selector);
-            this.notifyOverlay(activeTab.id, "ai.control.highlight", { selector: params.selector });
-            this.notifyOverlay(activeTab.id, "ai.control.status", { text: `Clicking ${params.selector}` });
-            await this.executeScriptWithTimeout(
-              activeTab.id,
-              `document.querySelector('${selector}')?.click()`
-            );
-            return { success: true };
-          }
-          throw new Error("No active tab or selector");
-        }
-        case "hanzo.fill": {
-          if (activeTab?.id && params.selector) {
-            const selector = this.escapeSelector(params.selector);
-            const value = this.escapeValue(params.value || "");
-            this.notifyOverlay(activeTab.id, "ai.control.highlight", { selector: params.selector });
-            this.notifyOverlay(activeTab.id, "ai.control.status", { text: `Filling ${params.selector}` });
-            await this.executeScriptWithTimeout(activeTab.id, `
-            var el = document.querySelector('${selector}');
-            if (el) {
-              el.value = '${value}';
-              el.dispatchEvent(new Event('input', {bubbles: true}));
-              el.dispatchEvent(new Event('change', {bubbles: true}));
-            }
-          `);
-            return { success: true };
-          }
-          throw new Error("No active tab or selector");
-        }
-        case "hanzo.control.start": {
-          const targetTabId = await this.resolveControlTabId(params.tabId);
-          if (targetTabId) {
-            await this.startControlSession(targetTabId, params.task);
-            return { success: true };
-          }
-          throw new Error("No active tab");
-        }
-        case "hanzo.control.stop": {
-          await this.stopControlSession();
-          return { success: true };
-        }
-        case "hanzo.type": {
-          if (activeTab?.id && params.text) {
-            const text = this.escapeValue(params.text);
-            await this.executeScriptWithTimeout(activeTab.id, `
-            var el = document.activeElement;
-            if (el && (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA')) {
-              el.value += '${text}';
-              el.dispatchEvent(new Event('input', {bubbles: true}));
-            }
-          `);
-            return { success: true };
-          }
-          throw new Error("No active tab or text");
-        }
-        case "Browser.getVersion": {
-          return {
-            protocolVersion: "1.3",
-            product: "Hanzo Firefox Extension",
-            userAgent: navigator.userAgent
-          };
-        }
-        case "hanzo.getTabs":
-        case "hanzo.listTabs": {
-          const tabs = await browser.tabs.query({});
-          return {
-            tabs: tabs.map((tab) => ({
-              id: tab.id,
-              url: tab.url,
-              title: tab.title,
-              active: tab.active
-            }))
-          };
-        }
-        default:
-          console.warn("[Hanzo] Unknown method:", method);
-          return { error: `Unknown method: ${method}` };
-      }
-    }
-    notifyOverlay(tabId, action, data) {
-      browser.tabs.sendMessage(tabId, { action, ...data }).catch(() => {
-      });
-    }
-    async getActiveTabId() {
-      const [tab] = await browser.tabs.query({ active: true, currentWindow: true });
-      return tab?.id ?? null;
-    }
-    async resolveControlTabId(tabId) {
-      if (typeof tabId === "number") return tabId;
-      if (controlSession.active && controlSession.tabId !== null) return controlSession.tabId;
-      return this.getActiveTabId();
-    }
-    async startControlSession(tabId, task) {
-      if (controlSession.active && controlSession.tabId !== null && controlSession.tabId !== tabId) {
-        this.notifyOverlay(controlSession.tabId, "ai.control.stop", {});
-      }
-      controlSession.active = true;
-      controlSession.tabId = tabId;
-      controlSession.task = task || "AI is controlling this page";
-      controlSession.startedAt = Date.now();
-      this.notifyOverlay(tabId, "ai.control.start", { task: controlSession.task });
-    }
-    async stopControlSession() {
-      if (controlSession.active && controlSession.tabId !== null) {
-        this.notifyOverlay(controlSession.tabId, "ai.control.stop", {});
-      }
-      controlSession.active = false;
-      controlSession.tabId = null;
-      controlSession.task = null;
-      controlSession.startedAt = null;
-    }
-    escapeSelector(selector) {
-      return selector.replace(/'/g, "\\'");
-    }
-    escapeValue(value) {
-      return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n");
-    }
-  };
-  async function getRagConfig() {
-    const result = await browser.storage.local.get([
-      "hanzo_rag_endpoint",
-      "hanzo_rag_api_key",
-      "hanzo_rag_kb",
-      "hanzo_rag_top_k",
-      "hanzo_rag_include_tab_context"
-    ]);
-    const topKParsed = Number.parseInt(String(result.hanzo_rag_top_k ?? 5), 10);
-    return {
-      endpoint: String(result.hanzo_rag_endpoint || "").trim(),
-      apiKey: String(result.hanzo_rag_api_key || "").trim(),
-      knowledgeBase: String(result.hanzo_rag_kb || "").trim(),
-      topK: Number.isFinite(topKParsed) ? Math.max(1, Math.min(topKParsed, 20)) : 5,
-      includeTabContext: result.hanzo_rag_include_tab_context !== false
-    };
-  }
-  function normalizeRagSnippets(raw) {
-    if (!raw) return [];
-    const candidates = [];
-    if (Array.isArray(raw)) candidates.push(...raw);
-    if (Array.isArray(raw?.snippets)) candidates.push(...raw.snippets);
-    if (Array.isArray(raw?.documents)) candidates.push(...raw.documents);
-    if (Array.isArray(raw?.items)) candidates.push(...raw.items);
-    if (Array.isArray(raw?.results)) candidates.push(...raw.results);
-    if (!candidates.length && typeof raw?.content === "string") {
-      candidates.push({ content: raw.content, source: raw.source || "rag-endpoint" });
-    }
-    return candidates.map((item) => {
-      const content = String(item?.content ?? item?.text ?? item?.snippet ?? item?.body ?? "").trim();
-      if (!content) return null;
-      return {
-        content,
-        title: item?.title ? String(item.title) : void 0,
-        source: item?.source ? String(item.source) : void 0,
-        score: typeof item?.score === "number" ? item.score : void 0,
-        url: item?.url ? String(item.url) : void 0
-      };
-    }).filter((item) => !!item).slice(0, 20);
-  }
-  async function queryRagEndpoint(params) {
-    if (!params.endpoint) return [];
-    const headers = { "Content-Type": "application/json" };
-    if (params.apiKey) headers.Authorization = `Bearer ${params.apiKey}`;
-    const response = await fetch(params.endpoint, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        query: params.query,
-        top_k: params.topK,
-        knowledge_base: params.knowledgeBase || void 0,
-        page_context: params.includeTabContext ? params.pageContext : void 0,
-        source: "hanzo-browser-extension-firefox"
-      })
-    });
-    if (!response.ok) {
-      const text = await response.text();
-      throw new Error(`RAG endpoint error ${response.status}: ${text || "Unknown error"}`);
-    }
-    const raw = await response.json();
-    return normalizeRagSnippets(raw).map((snippet) => ({
-      ...snippet,
-      source: snippet.source || "rag-endpoint"
-    }));
-  }
-  browser.runtime.onMessage.addListener((request, sender, sendResponse) => {
-    (async () => {
-      switch (request.action) {
-        // --- Auth (shared module — same code as Chrome) ---
-        case "auth.login":
-          try {
-            const user = await login();
-            sendResponse({ success: true, user });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        case "auth.logout":
-          try {
-            await logout();
-            sendResponse({ success: true });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        case "auth.status":
-          try {
-            const status = await getAuthStatus();
-            sendResponse({ success: true, ...status });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        case "auth.getToken":
-          try {
-            const token = await getValidAccessToken();
-            sendResponse({ success: !!token, token });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        // --- Cloud Chat (shared module) ---
-        case "chat.listModels":
-          try {
-            const token = await getValidAccessToken();
-            if (!token) {
-              sendResponse({ success: false, error: "Not authenticated" });
-              break;
-            }
-            const models = await listModels(token);
-            sendResponse({ success: true, models });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        case "chat.complete":
-          try {
-            const token = await getValidAccessToken();
-            if (!token) {
-              sendResponse({ success: false, error: "Not authenticated" });
-              break;
-            }
-            const model = String(request.model || "gpt-4o");
-            const messagesInput = Array.isArray(request.messages) ? request.messages : [];
-            const messages = messagesInput.filter((m) => m && typeof m.content === "string" && typeof m.role === "string").map((m) => ({
-              role: m.role === "system" || m.role === "assistant" ? m.role : "user",
-              content: String(m.content)
-            })).slice(-24);
-            if (!messages.length) {
-              sendResponse({ success: false, error: "messages are required" });
-              break;
-            }
-            const content = await chatCompletion(token, {
-              model,
-              messages,
-              temperature: typeof request.temperature === "number" ? request.temperature : void 0,
-              max_tokens: typeof request.max_tokens === "number" ? request.max_tokens : void 0
-            });
-            sendResponse({ success: true, content });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        // --- ZAP Protocol (not available on Firefox — return proper status) ---
-        case "zap.status":
-          sendResponse({ success: true, zap: { connected: false, mcps: [], extensionId: "firefox" } });
-          break;
-        case "zap.discover":
-          sendResponse({ success: true, mcps: [] });
-          break;
-        case "zap.listTools":
-          sendResponse({ success: true, tools: [] });
-          break;
-        case "zap.connect":
-        case "zap.callTool":
-          sendResponse({ success: false, error: "ZAP protocol not available on Firefox yet" });
-          break;
-        // --- Element selection (click-to-code) ---
-        case "elementSelected":
-          if (hanzoExtension.isConnected()) {
-            hanzoExtension.sendToWs({
-              type: "elementSelected",
-              data: request.data
-            });
-          }
-          sendResponse({ success: true });
-          break;
-        // --- Tab Filesystem ---
-        case "listTabFS": {
-          const allTabs = await browser.tabs.query({});
-          sendResponse({
-            success: true,
-            tabs: allTabs.map((tab) => ({
-              id: tab.id,
-              url: tab.url,
-              title: tab.title,
-              active: tab.active
-            }))
-          });
-          break;
-        }
-        case "readTabFS":
-          sendResponse({ success: false, error: "Tab filesystem read not available on Firefox" });
-          break;
-        case "writeTabFS":
-          sendResponse({ success: false, error: "Tab filesystem write not available on Firefox" });
-          break;
-        // --- WebGPU / Local AI ---
-        case "checkWebGPU": {
-          try {
-            if (!navigator.gpu) {
-              sendResponse({ available: false });
-              break;
-            }
-            const adapter = await navigator.gpu.requestAdapter();
-            sendResponse({
-              available: !!adapter,
-              adapter: adapter?.name || "Unknown GPU",
-              models: []
-            });
-          } catch {
-            sendResponse({ available: false });
-          }
-          break;
-        }
-        case "runLocalAI":
-          sendResponse({ success: false, error: "Local AI not available on Firefox" });
-          break;
-        case "listAgents":
-          sendResponse({ success: true, agents: [] });
-          break;
-        case "stopAgent":
-          sendResponse({ success: false, error: "Agent workers not available on Firefox" });
-          break;
-        case "launchAIWorker":
-          sendResponse({ success: false, error: "AI workers not available on Firefox" });
-          break;
-        // --- RAG ---
-        case "rag.query": {
-          try {
-            const config = await getRagConfig();
-            const topKInput = Number.parseInt(String(request.topK ?? config.topK), 10);
-            const params = {
-              endpoint: String(request.endpoint ?? config.endpoint ?? "").trim(),
-              apiKey: String(request.apiKey ?? config.apiKey ?? "").trim(),
-              query: String(request.query || "").trim(),
-              topK: Number.isFinite(topKInput) ? Math.max(1, Math.min(topKInput, 20)) : 5,
-              knowledgeBase: String(request.knowledgeBase ?? config.knowledgeBase ?? "").trim(),
-              includeTabContext: request.includeTabContext !== void 0 ? !!request.includeTabContext : config.includeTabContext,
-              pageContext: request.pageContext && typeof request.pageContext === "object" ? {
-                url: request.pageContext.url ? String(request.pageContext.url) : void 0,
-                title: request.pageContext.title ? String(request.pageContext.title) : void 0
-              } : void 0
-            };
-            if (!params.query) {
-              sendResponse({ success: false, error: "Query is required" });
-              break;
-            }
-            if (!params.endpoint) {
-              sendResponse({ success: true, source: "none", snippets: [] });
-              break;
-            }
-            const snippets = await queryRagEndpoint(params);
-            sendResponse({ success: true, source: snippets.length ? "rag-endpoint" : "none", snippets });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        // --- Bridge status ---
-        case "bridge.status":
-          sendResponse({
-            success: true,
-            connected: hanzoExtension.isConnected(),
-            browsers: hanzoExtension.isConnected() ? ["firefox"] : []
-          });
-          break;
-        // --- Config ---
-        case "config.save":
-          sendResponse({ success: true });
-          break;
-        // --- In-page overlay (forwarded to content script) ---
-        case "page.overlay.toggle":
-        case "page.overlay.show":
-        case "page.overlay.hide":
-        case "page.overlay.status": {
-          try {
-            const tabId = typeof request.tabId === "number" ? request.tabId : sender.tab?.id ?? await hanzoExtension.getActiveTabId();
-            if (tabId === null) {
-              sendResponse({ success: false, error: "No target tab" });
-              break;
-            }
-            const response = await browser.tabs.sendMessage(tabId, { action: request.action }).catch(() => null);
-            sendResponse({ success: true, tabId, ...response || {} });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        // --- AI Control Overlay ---
-        case "ai.control.start":
-        case "ai.control.cursor":
-        case "ai.control.highlight":
-        case "ai.control.status": {
-          const targetTabId = request.tabId || controlSession.tabId || await hanzoExtension.getActiveTabId();
-          if (!targetTabId) {
-            sendResponse({ success: false, error: "No target tab found" });
-            break;
-          }
-          if (request.action !== "ai.control.start" && controlSession.active && controlSession.tabId && targetTabId !== controlSession.tabId) {
-            sendResponse({ success: false, error: `Control locked to tab ${controlSession.tabId}` });
-            break;
-          }
-          if (request.action === "ai.control.start") {
-            await hanzoExtension.startControlSession(targetTabId, request.task);
-          } else {
-            browser.tabs.sendMessage(targetTabId, request).catch(() => {
-            });
-          }
-          sendResponse({ success: true, tabId: targetTabId });
-          break;
-        }
-        case "ai.control.stop":
-        case "ai.control.cancel":
-          await hanzoExtension.stopControlSession();
-          sendResponse({ success: true });
-          break;
-        default:
-          sendResponse({ success: false, error: `Unknown action: ${request.action}` });
-          break;
-      }
-    })();
-    return true;
-  });
-  var hanzoExtension = new HanzoFirefoxExtension();
-  browser.tabs.onRemoved.addListener((tabId) => {
-    if (controlSession.active && controlSession.tabId === tabId) {
-      void hanzoExtension.stopControlSession();
-    }
-  });
-  console.log("[Hanzo] Firefox background script loaded");
-})();