@hanzo/browser-extension 1.7.2 → 1.7.6

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

@@ -1,5 +1,253 @@
 "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,
@@ -13,7 +261,14 @@
       this.cdpPort = 9223;
       this.reconnectTimeout = 3e3;
       console.log("[Hanzo] Firefox extension initializing...");
-      this.connect();
+      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`;
@@ -34,16 +289,23 @@
           this.send({ id: 0, error: { code: -1, message: String(e) } });
         }
       };
-      this.wsConnection.onerror = (error) => {
-        console.error("[Hanzo] WebSocket error:", error);
+      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.send({
+      this.sendToWs({
         type: "register",
         role: "cdp-provider",
         capabilities: [
@@ -61,9 +323,7 @@
       });
     }
     send(data) {
-      if (this.wsConnection?.readyState === WebSocket.OPEN) {
-        this.wsConnection.send(JSON.stringify(data));
-      }
+      this.sendToWs(data);
     }
     async handleCommand(message) {
       const { id, method, params = {} } = message;
@@ -74,9 +334,6 @@
         return { id, error: { code: -1, message: String(e) } };
       }
     }
-    /**
-     * Wrap executeScript with a timeout to prevent blocking on GPU-heavy pages
-     */
     executeScriptWithTimeout(tabId, code, timeoutMs = 1e4) {
       return Promise.race([
         browser.tabs.executeScript(tabId, { code }),
@@ -102,17 +359,12 @@
             }))
           };
         }
-        // Native tab property reads - never block on page content
         case "hanzo.url": {
-          if (activeTab) {
-            return { result: { value: activeTab.url || "" } };
-          }
+          if (activeTab) return { result: { value: activeTab.url || "" } };
           throw new Error("No active tab");
         }
         case "hanzo.title": {
-          if (activeTab) {
-            return { result: { value: activeTab.title || "" } };
-          }
+          if (activeTab) return { result: { value: activeTab.title || "" } };
           throw new Error("No active tab");
         }
         case "hanzo.tabInfo": {
@@ -164,11 +416,7 @@
           if (activeTab?.id) {
             const expression = params.expression;
             const timeout = params.timeout || 1e4;
-            const results = await this.executeScriptWithTimeout(
-              activeTab.id,
-              expression,
-              timeout
-            );
+            const results = await this.executeScriptWithTimeout(activeTab.id, expression, timeout);
             return { result: { value: results[0] } };
           }
           throw new Error("No active tab");
@@ -202,17 +450,14 @@
             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}));
-              }
-            `
-            );
+            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");
@@ -232,16 +477,13 @@
         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}));
-              }
-            `
-            );
+            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");
@@ -309,31 +551,6 @@
       return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n");
     }
   };
-  var IAM_BASE = "https://hanzo.id";
-  var API_BASE = "https://api.hanzo.ai";
-  var CLIENT_ID = "app-hanzo";
-  var SCOPES = "openid profile email";
-  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"
-  };
-  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) {
-    return crypto.subtle.digest("SHA-256", new TextEncoder().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 getRagConfig() {
     const result = await browser.storage.local.get([
       "hanzo_rag_endpoint",
@@ -376,9 +593,7 @@
   }
   async function queryRagEndpoint(params) {
     if (!params.endpoint) return [];
-    const headers = {
-      "Content-Type": "application/json"
-    };
+    const headers = { "Content-Type": "application/json" };
     if (params.apiKey) headers.Authorization = `Bearer ${params.apiKey}`;
     const response = await fetch(params.endpoint, {
       method: "POST",
@@ -401,117 +616,129 @@
       source: snippet.source || "rag-endpoint"
     }));
   }
-  async function firefoxLogin() {
-    const codeVerifier = generateRandomString(64);
-    const codeChallenge = base64UrlEncode(await sha256(codeVerifier));
-    const state = generateRandomString(32);
-    const redirectUri = "https://hanzo.ai/callback";
-    const authorizeUrl = new URL(`${IAM_BASE}/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 new Promise((resolve, reject) => {
-      let authTabId;
-      const timeout = setTimeout(() => {
-        cleanup();
-        reject(new Error("Login timed out"));
-      }, 3e5);
-      function cleanup() {
-        clearTimeout(timeout);
-        browser.tabs.onUpdated.removeListener(onUpdated);
-        browser.tabs.onRemoved.removeListener(onRemoved);
-      }
-      function onUpdated(tabId, changeInfo) {
-        if (tabId !== authTabId || !changeInfo.url) return;
-        if (changeInfo.url.startsWith(redirectUri)) {
-          cleanup();
-          browser.tabs.remove(tabId).catch(() => {
-          });
-          resolve(changeInfo.url);
-        }
-      }
-      function onRemoved(tabId) {
-        if (tabId !== authTabId) return;
-        cleanup();
-        reject(new Error("Login cancelled"));
-      }
-      browser.tabs.onUpdated.addListener(onUpdated);
-      browser.tabs.onRemoved.addListener(onRemoved);
-      browser.tabs.create({ url: authorizeUrl.toString() }).then((tab) => {
-        authTabId = tab.id;
-      });
-    });
-    const url = new URL(callbackUrl);
-    if (url.searchParams.get("state") !== state) throw new Error("State mismatch");
-    const code = url.searchParams.get("code");
-    if (!code) throw new Error(url.searchParams.get("error_description") || "No code");
-    const tokenResponse = await fetch(`${IAM_BASE}/oauth/token`, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body: new URLSearchParams({
-        grant_type: "authorization_code",
-        client_id: CLIENT_ID,
-        code,
-        redirect_uri: redirectUri,
-        code_verifier: codeVerifier
-      })
-    });
-    if (!tokenResponse.ok) throw new Error(`Token exchange failed: ${await tokenResponse.text()}`);
-    const tokens = await tokenResponse.json();
-    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;
-    await browser.storage.local.set(data);
-    const userResp = await fetch(`${IAM_BASE}/oauth/userinfo`, { headers: { Authorization: `Bearer ${tokens.access_token}` } });
-    const user = userResp.ok ? await userResp.json() : {};
-    await browser.storage.local.set({ [STORAGE_KEYS.user]: user });
-    return user;
-  }
   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 firefoxLogin();
+            const user = await login();
             sendResponse({ success: true, user });
           } catch (e) {
             sendResponse({ success: false, error: e.message });
           }
           break;
         case "auth.logout":
-          await browser.storage.local.remove(Object.values(STORAGE_KEYS));
+          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;
-        case "auth.status": {
-          const result = await browser.storage.local.get([STORAGE_KEYS.accessToken, STORAGE_KEYS.user]);
+        // --- Tab Filesystem ---
+        case "listTabFS": {
+          const allTabs = await browser.tabs.query({});
           sendResponse({
             success: true,
-            authenticated: !!result[STORAGE_KEYS.accessToken],
-            user: result[STORAGE_KEYS.user] || null
+            tabs: allTabs.map((tab) => ({
+              id: tab.id,
+              url: tab.url,
+              title: tab.title,
+              active: tab.active
+            }))
           });
           break;
         }
-        case "auth.getToken": {
-          const r = await browser.storage.local.get([STORAGE_KEYS.accessToken]);
-          sendResponse({ success: !!r[STORAGE_KEYS.accessToken], token: r[STORAGE_KEYS.accessToken] || null });
+        case "readTabFS":
+          sendResponse({ success: false, error: "Tab filesystem read not available on Firefox" });
           break;
-        }
-        case "chat.listModels": {
-          const t = await browser.storage.local.get([STORAGE_KEYS.accessToken]);
-          if (!t[STORAGE_KEYS.accessToken]) {
-            sendResponse({ success: false, error: "Not authenticated" });
-            break;
-          }
-          const resp = await fetch(`${API_BASE}/v1/models`, { headers: { Authorization: `Bearer ${t[STORAGE_KEYS.accessToken]}` } });
-          const data = await resp.json();
-          sendResponse({ success: true, models: data.data || data.models || data || [] });
+        case "writeTabFS":
+          sendResponse({ success: false, error: "Tab filesystem write not available on Firefox" });
           break;
-        }
+        // --- WebGPU / Local AI ---
         case "checkWebGPU": {
           try {
             if (!navigator.gpu) {
@@ -529,15 +756,19 @@
           }
           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 are not available in Firefox background mode yet" });
+          sendResponse({ success: false, error: "Agent workers not available on Firefox" });
           break;
         case "launchAIWorker":
-          sendResponse({ success: false, error: "launchAIWorker is not implemented in Firefox background mode yet" });
+          sendResponse({ success: false, error: "AI workers not available on Firefox" });
           break;
+        // --- RAG ---
         case "rag.query": {
           try {
             const config = await getRagConfig();
@@ -569,7 +800,37 @@
           }
           break;
         }
-        // --- AI Control Overlay (forwarded to content script) ---
+        // --- 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":
@@ -593,9 +854,6 @@
           break;
         }
         case "ai.control.stop":
-          await hanzoExtension.stopControlSession();
-          sendResponse({ success: true });
-          break;
         case "ai.control.cancel":
           await hanzoExtension.stopControlSession();
           sendResponse({ success: true });