@hanzo/browser-extension 1.7.6 → 1.9.31

package/dist/browser-extension/browser-control.js

@@ -365,6 +365,405 @@ var BrowserControl = class {
     `);
   }
   // ===========================================================================
+  // DOM Read/Write/Observe
+  // ===========================================================================
+  async getHTML(tabId, selector, outer = true) {
+    return this.executeScript(tabId, `
+      (() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        return el ? (${outer} ? el.outerHTML : el.innerHTML) : null;
+      })()
+    `);
+  }
+  async setHTML(tabId, selector, html, outer = false) {
+    return this.executeScript(tabId, `
+      (() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return false;
+        ${outer ? `el.outerHTML = ${JSON.stringify(html)};` : `el.innerHTML = ${JSON.stringify(html)};`}
+        return true;
+      })()
+    `);
+  }
+  async getText(tabId, selector) {
+    return this.executeScript(tabId, `
+      (() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        return el ? el.textContent : null;
+      })()
+    `);
+  }
+  async setText(tabId, selector, text) {
+    return this.executeScript(tabId, `
+      (() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return false;
+        el.textContent = ${JSON.stringify(text)};
+        return true;
+      })()
+    `);
+  }
+  async getAttribute(tabId, selector, attr) {
+    return this.executeScript(tabId, `
+      document.querySelector(${JSON.stringify(selector)})?.getAttribute(${JSON.stringify(attr)}) ?? null
+    `);
+  }
+  async setAttribute(tabId, selector, attr, value) {
+    return this.executeScript(tabId, `
+      (() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return false;
+        el.setAttribute(${JSON.stringify(attr)}, ${JSON.stringify(value)});
+        return true;
+      })()
+    `);
+  }
+  async removeAttribute(tabId, selector, attr) {
+    return this.executeScript(tabId, `
+      (() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return false;
+        el.removeAttribute(${JSON.stringify(attr)});
+        return true;
+      })()
+    `);
+  }
+  async setStyle(tabId, selector, styles) {
+    return this.executeScript(tabId, `
+      (() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return false;
+        Object.assign(el.style, ${JSON.stringify(styles)});
+        return true;
+      })()
+    `);
+  }
+  async addClass(tabId, selector, ...classNames) {
+    return this.executeScript(tabId, `
+      (() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return false;
+        el.classList.add(${classNames.map((c) => JSON.stringify(c)).join(",")});
+        return true;
+      })()
+    `);
+  }
+  async removeClass(tabId, selector, ...classNames) {
+    return this.executeScript(tabId, `
+      (() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return false;
+        el.classList.remove(${classNames.map((c) => JSON.stringify(c)).join(",")});
+        return true;
+      })()
+    `);
+  }
+  async insertElement(tabId, parentSelector, html, position = "beforeend") {
+    return this.executeScript(tabId, `
+      (() => {
+        const parent = document.querySelector(${JSON.stringify(parentSelector)});
+        if (!parent) return false;
+        parent.insertAdjacentHTML(${JSON.stringify(position)}, ${JSON.stringify(html)});
+        return true;
+      })()
+    `);
+  }
+  async removeElement(tabId, selector) {
+    return this.executeScript(tabId, `
+      (() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return false;
+        el.remove();
+        return true;
+      })()
+    `);
+  }
+  async observeMutations(tabId, selector, options = {}, durationMs = 5e3) {
+    const opts = { childList: true, subtree: true, attributes: true, ...options };
+    return this.executeScript(tabId, `
+      new Promise((resolve) => {
+        const target = ${selector === "document" ? "document.documentElement" : `document.querySelector(${JSON.stringify(selector)})`};
+        if (!target) { resolve([]); return; }
+        const mutations = [];
+        const observer = new MutationObserver((records) => {
+          for (const r of records) {
+            mutations.push({
+              type: r.type,
+              target: r.target.nodeName + (r.target.id ? '#' + r.target.id : ''),
+              added: r.addedNodes.length,
+              removed: r.removedNodes.length,
+              attribute: r.attributeName || null,
+              oldValue: r.oldValue?.substring(0, 200) || null,
+            });
+            if (mutations.length >= 200) { observer.disconnect(); resolve(mutations); }
+          }
+        });
+        observer.observe(target, ${JSON.stringify(opts)});
+        setTimeout(() => { observer.disconnect(); resolve(mutations); }, ${durationMs});
+      })
+    `);
+  }
+  async getComputedStyles(tabId, selector, properties) {
+    return this.executeScript(tabId, `
+      (() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return null;
+        const cs = window.getComputedStyle(el);
+        ${properties ? `return Object.fromEntries(${JSON.stringify(properties)}.map(p => [p, cs.getPropertyValue(p)]));` : `
+        const props = ['display','visibility','opacity','position','width','height','margin','padding',
+          'color','background','font-size','font-weight','border','overflow','z-index','transform'];
+        return Object.fromEntries(props.map(p => [p, cs.getPropertyValue(p)]));`}
+      })()
+    `);
+  }
+  async getBoundingRects(tabId, selector) {
+    return this.executeScript(tabId, `
+      Array.from(document.querySelectorAll(${JSON.stringify(selector)})).slice(0, 50).map(el => {
+        const r = el.getBoundingClientRect();
+        return { tag: el.tagName.toLowerCase(), id: el.id, x: r.x, y: r.y, w: r.width, h: r.height };
+      })
+    `);
+  }
+  async injectScript(tabId, url) {
+    return this.executeScript(tabId, `
+      new Promise((resolve) => {
+        const s = document.createElement('script');
+        s.src = ${JSON.stringify(url)};
+        s.onload = () => resolve(true);
+        s.onerror = () => resolve(false);
+        document.head.appendChild(s);
+      })
+    `);
+  }
+  async injectCSS(tabId, css) {
+    return this.executeScript(tabId, `
+      (() => {
+        const style = document.createElement('style');
+        style.textContent = ${JSON.stringify(css)};
+        document.head.appendChild(style);
+        return true;
+      })()
+    `);
+  }
+  async getLocalStorage(tabId, key) {
+    if (key) {
+      return this.executeScript(tabId, `localStorage.getItem(${JSON.stringify(key)})`);
+    }
+    return this.executeScript(tabId, `JSON.parse(JSON.stringify(localStorage))`);
+  }
+  async setLocalStorage(tabId, key, value) {
+    return this.executeScript(tabId, `
+      (() => { localStorage.setItem(${JSON.stringify(key)}, ${JSON.stringify(value)}); return true; })()
+    `);
+  }
+  async getCookies(tabId) {
+    return new Promise((resolve) => {
+      chrome.tabs.get(tabId, (tab) => {
+        if (!tab?.url) {
+          resolve([]);
+          return;
+        }
+        chrome.cookies.getAll({ url: tab.url }, (cookies) => {
+          resolve(cookies || []);
+        });
+      });
+    });
+  }
+  async setCookie(tabId, cookie) {
+    return new Promise((resolve) => {
+      chrome.tabs.get(tabId, (tab) => {
+        if (!tab?.url) {
+          resolve(false);
+          return;
+        }
+        chrome.cookies.set({ url: tab.url, ...cookie }, (c) => resolve(!!c));
+      });
+    });
+  }
+  async deleteCookie(tabId, name) {
+    return new Promise((resolve) => {
+      chrome.tabs.get(tabId, (tab) => {
+        if (!tab?.url) {
+          resolve(false);
+          return;
+        }
+        chrome.cookies.remove({ url: tab.url, name }, () => resolve(true));
+      });
+    });
+  }
+  async getSessionStorage(tabId, key) {
+    if (key) {
+      return this.executeScript(tabId, `sessionStorage.getItem(${JSON.stringify(key)})`);
+    }
+    return this.executeScript(tabId, `JSON.parse(JSON.stringify(sessionStorage))`);
+  }
+  async setSessionStorage(tabId, key, value) {
+    return this.executeScript(tabId, `
+      (() => { sessionStorage.setItem(${JSON.stringify(key)}, ${JSON.stringify(value)}); return true; })()
+    `);
+  }
+  async getIndexedDBDatabases(tabId) {
+    return this.executeScript(tabId, `
+      (async () => {
+        const dbs = await indexedDB.databases();
+        return dbs.map(db => ({ name: db.name, version: db.version }));
+      })()
+    `);
+  }
+  async queryIndexedDB(tabId, dbName, storeName, query) {
+    const count = query?.count || 100;
+    return this.executeScript(tabId, `
+      new Promise((resolve, reject) => {
+        const req = indexedDB.open(${JSON.stringify(dbName)});
+        req.onerror = () => reject(new Error(req.error?.message || 'Failed to open DB'));
+        req.onsuccess = () => {
+          const db = req.result;
+          try {
+            const tx = db.transaction(${JSON.stringify(storeName)}, 'readonly');
+            const store = tx.objectStore(${JSON.stringify(storeName)});
+            const src = ${query?.index ? `store.index(${JSON.stringify(query.index)})` : "store"};
+            const getReq = ${query?.key ? `src.get(${JSON.stringify(query.key)})` : `src.getAll(null, ${count})`};
+            getReq.onsuccess = () => resolve(${query?.key ? "[getReq.result]" : "getReq.result"});
+            getReq.onerror = () => reject(new Error(getReq.error?.message || 'Query failed'));
+          } catch(e) { reject(e); }
+        };
+      })
+    `);
+  }
+  async getIndexedDBStores(tabId, dbName) {
+    return this.executeScript(tabId, `
+      new Promise((resolve, reject) => {
+        const req = indexedDB.open(${JSON.stringify(dbName)});
+        req.onerror = () => reject(new Error(req.error?.message || 'Failed to open DB'));
+        req.onsuccess = () => {
+          resolve(Array.from(req.result.objectStoreNames));
+        };
+      })
+    `);
+  }
+  async clearSiteData(tabId, what = ["all"]) {
+    const doAll = what.includes("all");
+    const results = {};
+    if (doAll || what.includes("cookies")) {
+      await new Promise((resolve) => {
+        chrome.tabs.get(tabId, (tab) => {
+          if (!tab?.url) {
+            results.cookies = false;
+            resolve();
+            return;
+          }
+          chrome.cookies.getAll({ url: tab.url }, (cookies) => {
+            Promise.all((cookies || []).map(
+              (c) => new Promise((r) => chrome.cookies.remove({ url: tab.url, name: c.name }, () => r()))
+            )).then(() => {
+              results.cookies = true;
+              resolve();
+            });
+          });
+        });
+      });
+    }
+    if (doAll || what.includes("localStorage")) {
+      results.localStorage = await this.executeScript(tabId, `(() => { localStorage.clear(); return true; })()`);
+    }
+    if (doAll || what.includes("sessionStorage")) {
+      results.sessionStorage = await this.executeScript(tabId, `(() => { sessionStorage.clear(); return true; })()`);
+    }
+    if (doAll || what.includes("indexedDB")) {
+      results.indexedDB = await this.executeScript(tabId, `
+        (async () => {
+          const dbs = await indexedDB.databases();
+          await Promise.all(dbs.map(db => new Promise((r, j) => {
+            const req = indexedDB.deleteDatabase(db.name);
+            req.onsuccess = () => r(true);
+            req.onerror = () => r(false);
+          })));
+          return true;
+        })()
+      `);
+    }
+    if (doAll || what.includes("cache")) {
+      results.cache = await this.executeScript(tabId, `
+        (async () => {
+          const keys = await caches.keys();
+          await Promise.all(keys.map(k => caches.delete(k)));
+          return true;
+        })()
+      `);
+    }
+    return results;
+  }
+  async getCacheStorageKeys(tabId) {
+    return this.executeScript(tabId, `caches.keys()`);
+  }
+  async checkWebGPU(tabId) {
+    return this.executeScript(tabId, `
+      (async () => {
+        if (!navigator.gpu) return { available: false, reason: 'WebGPU not supported' };
+        try {
+          const adapter = await navigator.gpu.requestAdapter();
+          if (!adapter) return { available: false, reason: 'No GPU adapter' };
+          const info = await adapter.requestAdapterInfo();
+          return {
+            available: true,
+            adapter: info.description || info.device || info.vendor || 'Unknown',
+            vendor: info.vendor,
+            architecture: info.architecture,
+            features: [...adapter.features].sort(),
+            limits: {
+              maxBufferSize: adapter.limits.maxBufferSize,
+              maxTextureDimension2D: adapter.limits.maxTextureDimension2D,
+              maxComputeWorkgroupSizeX: adapter.limits.maxComputeWorkgroupSizeX,
+              maxBindGroups: adapter.limits.maxBindGroups,
+              maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,
+            },
+          };
+        } catch(e) { return { available: false, reason: e.message }; }
+      })()
+    `);
+  }
+  async hardReload(tabId) {
+    chrome.tabs.reload(tabId, { bypassCache: true });
+  }
+  async getServiceWorkers(tabId) {
+    return this.executeScript(tabId, `
+      (async () => {
+        const regs = await navigator.serviceWorker?.getRegistrations() || [];
+        return regs.map(r => ({
+          scope: r.scope,
+          active: r.active ? { state: r.active.state, scriptURL: r.active.scriptURL } : null,
+          waiting: r.waiting ? { state: r.waiting.state } : null,
+          installing: r.installing ? { state: r.installing.state } : null,
+        }));
+      })()
+    `);
+  }
+  async getPerformanceMetrics(tabId) {
+    return this.executeScript(tabId, `
+      (() => {
+        const nav = performance.getEntriesByType('navigation')[0] || {};
+        const paint = performance.getEntriesByType('paint');
+        const resources = performance.getEntriesByType('resource');
+        return {
+          timing: {
+            domContentLoaded: Math.round(nav.domContentLoadedEventEnd - nav.startTime),
+            load: Math.round(nav.loadEventEnd - nav.startTime),
+            ttfb: Math.round(nav.responseStart - nav.startTime),
+            domInteractive: Math.round(nav.domInteractive - nav.startTime),
+          },
+          paint: Object.fromEntries(paint.map(p => [p.name, Math.round(p.startTime)])),
+          resourceCount: resources.length,
+          transferSize: resources.reduce((s, r) => s + (r.transferSize || 0), 0),
+          memory: performance.memory ? {
+            usedJSHeapSize: performance.memory.usedJSHeapSize,
+            totalJSHeapSize: performance.memory.totalJSHeapSize,
+            jsHeapSizeLimit: performance.memory.jsHeapSizeLimit,
+          } : null,
+        };
+      })()
+    `);
+  }
+  // ===========================================================================
   // Navigation
   // ===========================================================================
   async navigateTo(tabId, url) {
@@ -386,6 +785,74 @@ var BrowserControl = class {
       });
     });
   }
+  async getURL(tabId) {
+    return new Promise((resolve) => {
+      chrome.tabs.get(tabId, (tab) => resolve(tab?.url || ""));
+    });
+  }
+  async getTitle(tabId) {
+    return new Promise((resolve) => {
+      chrome.tabs.get(tabId, (tab) => resolve(tab?.title || ""));
+    });
+  }
+  async getTabInfo(tabId) {
+    return new Promise((resolve) => {
+      chrome.tabs.get(tabId, (tab) => resolve({
+        id: tab?.id,
+        url: tab?.url,
+        title: tab?.title,
+        status: tab?.status,
+        active: tab?.active,
+        index: tab?.index,
+        pinned: tab?.pinned,
+        incognito: tab?.incognito
+      }));
+    });
+  }
+  async getHistory(tabId, maxResults = 50) {
+    return this.executeScript(tabId, `
+      (() => {
+        const entries = performance.getEntriesByType('navigation');
+        return {
+          length: history.length,
+          scrollRestoration: history.scrollRestoration,
+          current: location.href,
+          navigation: entries.map(e => ({
+            type: e.type,
+            redirectCount: e.redirectCount,
+            duration: Math.round(e.duration),
+          })),
+        };
+      })()
+    `);
+  }
+  async browserFetch(tabId, url, options) {
+    const opts = {
+      method: options?.method || "GET",
+      headers: options?.headers || {},
+      body: options?.body,
+      mode: options?.mode || "cors",
+      credentials: options?.credentials || "include"
+    };
+    return this.executeScript(tabId, `
+      (async () => {
+        const opts = ${JSON.stringify(opts)};
+        if (!opts.body) delete opts.body;
+        const res = await fetch(${JSON.stringify(url)}, opts);
+        const headers = {};
+        res.headers.forEach((v, k) => headers[k] = v);
+        const ct = res.headers.get('content-type') || '';
+        let body;
+        if (ct.includes('json')) {
+          body = JSON.stringify(await res.json());
+        } else {
+          body = await res.text();
+        }
+        if (body.length > 500000) body = body.substring(0, 500000) + '...(truncated)';
+        return { status: res.status, statusText: res.statusText, headers, body, url: res.url };
+      })()
+    `);
+  }
   async closeTab(tabId) {
     chrome.tabs.remove(tabId);
   }
@@ -597,9 +1064,33 @@ var BrowserControl = class {
         case "browser.scroll":
           sendResponse({ success: await this.scroll(tabId, request.x, request.y, request.selector) });
           break;
+        case "browser.dblclick":
+          sendResponse({ success: await this.doubleClick(tabId, request.selector) });
+          break;
         case "browser.hover":
           sendResponse({ success: await this.hover(tabId, request.selector) });
           break;
+        case "browser.clear":
+          sendResponse({ success: await this.fill(tabId, request.selector, "") });
+          break;
+        case "browser.check":
+          sendResponse({ success: await this.check(tabId, request.selector, true) });
+          break;
+        case "browser.uncheck":
+          sendResponse({ success: await this.check(tabId, request.selector, false) });
+          break;
+        case "browser.focus":
+          sendResponse({ success: await this.focus(tabId, request.selector) });
+          break;
+        case "browser.blur":
+          sendResponse({ success: await this.blur(tabId, request.selector) });
+          break;
+        case "browser.drag":
+          sendResponse({ success: await this.drag(tabId, request.from || request.selector, request.to) });
+          break;
+        case "browser.scrollIntoView":
+          sendResponse({ success: await this.scrollIntoView(tabId, request.selector) });
+          break;
         case "browser.pressKey":
           sendResponse({ success: await this.pressKey(tabId, request.key, request.modifiers) });
           break;
@@ -613,6 +1104,43 @@ var BrowserControl = class {
           await this.navigateTo(tabId, request.url);
           sendResponse({ success: true });
           break;
+        case "browser.goBack":
+          await this.goBack(tabId);
+          sendResponse({ success: true });
+          break;
+        case "browser.goForward":
+          await this.goForward(tabId);
+          sendResponse({ success: true });
+          break;
+        case "browser.reload":
+          await this.reload(tabId);
+          sendResponse({ success: true });
+          break;
+        case "browser.getURL":
+          sendResponse({ success: true, url: await this.getURL(tabId) });
+          break;
+        case "browser.getTitle":
+          sendResponse({ success: true, title: await this.getTitle(tabId) });
+          break;
+        case "browser.getTabInfo":
+          sendResponse({ success: true, info: await this.getTabInfo(tabId) });
+          break;
+        case "browser.waitForNavigation":
+          sendResponse({ success: await this.waitForNavigation(tabId, request.timeout) });
+          break;
+        case "browser.getHistory":
+          sendResponse({ success: true, history: await this.getHistory(tabId, request.maxResults) });
+          break;
+        case "browser.fetch":
+          sendResponse({ success: true, response: await this.browserFetch(tabId, request.url, request.options) });
+          break;
+        case "browser.createTab":
+          sendResponse({ success: true, tabId: await this.createTab(request.url || "about:blank", request.active !== false) });
+          break;
+        case "browser.closeTab":
+          await this.closeTab(tabId);
+          sendResponse({ success: true });
+          break;
         case "browser.waitForSelector":
           sendResponse({ success: await this.waitForSelector(tabId, request.selector, request.timeout) });
           break;
@@ -625,6 +1153,66 @@ var BrowserControl = class {
         case "browser.querySelectorAll":
           sendResponse({ success: true, elements: await this.querySelectorAll(tabId, request.selector) });
           break;
+        case "browser.getHTML":
+          sendResponse({ success: true, html: await this.getHTML(tabId, request.selector, request.outer !== false) });
+          break;
+        case "browser.setHTML":
+          sendResponse({ success: await this.setHTML(tabId, request.selector, request.html, request.outer) });
+          break;
+        case "browser.getText":
+          sendResponse({ success: true, text: await this.getText(tabId, request.selector) });
+          break;
+        case "browser.setText":
+          sendResponse({ success: await this.setText(tabId, request.selector, request.text) });
+          break;
+        case "browser.getAttribute":
+          sendResponse({ success: true, value: await this.getAttribute(tabId, request.selector, request.attr) });
+          break;
+        case "browser.setAttribute":
+          sendResponse({ success: await this.setAttribute(tabId, request.selector, request.attr, request.value) });
+          break;
+        case "browser.removeAttribute":
+          sendResponse({ success: await this.removeAttribute(tabId, request.selector, request.attr) });
+          break;
+        case "browser.setStyle":
+          sendResponse({ success: await this.setStyle(tabId, request.selector, request.styles) });
+          break;
+        case "browser.addClass":
+          sendResponse({ success: await this.addClass(tabId, request.selector, ...request.classNames || []) });
+          break;
+        case "browser.removeClass":
+          sendResponse({ success: await this.removeClass(tabId, request.selector, ...request.classNames || []) });
+          break;
+        case "browser.insertElement":
+          sendResponse({ success: await this.insertElement(tabId, request.selector, request.html, request.position) });
+          break;
+        case "browser.removeElement":
+          sendResponse({ success: await this.removeElement(tabId, request.selector) });
+          break;
+        case "browser.observeMutations":
+          sendResponse({ success: true, mutations: await this.observeMutations(tabId, request.selector || "document", request.options, request.duration) });
+          break;
+        case "browser.getComputedStyles":
+          sendResponse({ success: true, styles: await this.getComputedStyles(tabId, request.selector, request.properties) });
+          break;
+        case "browser.getBoundingRects":
+          sendResponse({ success: true, rects: await this.getBoundingRects(tabId, request.selector) });
+          break;
+        case "browser.injectScript":
+          sendResponse({ success: await this.injectScript(tabId, request.url) });
+          break;
+        case "browser.injectCSS":
+          sendResponse({ success: await this.injectCSS(tabId, request.css) });
+          break;
+        case "browser.getLocalStorage":
+          sendResponse({ success: true, data: await this.getLocalStorage(tabId, request.key) });
+          break;
+        case "browser.setLocalStorage":
+          sendResponse({ success: await this.setLocalStorage(tabId, request.key, request.value) });
+          break;
+        case "browser.getCookies":
+          sendResponse({ success: true, cookies: await this.getCookies(tabId) });
+          break;
         default:
           sendResponse({ success: false, error: `Unknown action: ${request.action}` });
       }
@@ -653,29 +1241,75 @@ var BrowserControl = class {
   // ===========================================================================
   // Script Execution Helper
   // ===========================================================================
-  executeScript(tabId, code) {
-    return new Promise((resolve, reject) => {
-      if (chrome.scripting) {
-        chrome.scripting.executeScript({
+  /**
+   * Run JS in a tab and return its result.
+   *
+   * Why MV3 + MAIN world + the Function trampoline?
+   *
+   *   - `chrome.scripting.executeScript` only accepts a function (or files);
+   *     it does NOT take a code string the way MV2's `tabs.executeScript`
+   *     did. To support our existing call sites that pass dynamic code as
+   *     a string, we serialise the user's code through `args` and run it
+   *     via `Function(codeStr)()` inside the page.
+   *   - MAIN world is required so the page's own globals (window.fetch,
+   *     CustomElements, framework instances) are visible. ISOLATED world
+   *     can't see them.
+   *   - Async unwrap: if the caller's code yields a Promise, executeScript
+   *     serialises it as `{}` (the value-loss bug). We detect that shape
+   *     and re-run wrapping in `Promise.resolve(...)` so the resolved
+   *     value comes back instead of the placeholder.
+   *
+   * Falls back to the MV2 string API on browsers / runtimes that still
+   * have it (older Firefox; no Chrome MV2 ships now).
+   */
+  async executeScript(tabId, code) {
+    const exec = async (wrapped) => {
+      if (chrome.scripting?.executeScript) {
+        const results = await chrome.scripting.executeScript({
           target: { tabId },
-          func: new Function(`return (${code})`)
-        }, (results) => {
-          if (chrome.runtime.lastError) {
-            reject(new Error(chrome.runtime.lastError.message));
-          } else {
-            resolve(results?.[0]?.result);
+          world: "MAIN",
+          args: [wrapped],
+          func: (codeStr) => {
+            try {
+              return Function(codeStr)();
+            } catch (e) {
+              return { __hanzo_error: e?.message || String(e) };
+            }
           }
         });
-      } else {
-        chrome.tabs.executeScript(tabId, { code }, (results) => {
-          if (chrome.runtime.lastError) {
-            reject(new Error(chrome.runtime.lastError.message));
-          } else {
-            resolve(results?.[0]);
-          }
+        return results?.[0]?.result;
+      }
+      const legacy = chrome.tabs.executeScript;
+      if (legacy) {
+        return new Promise((resolve, reject) => {
+          legacy(tabId, { code: wrapped }, (results) => {
+            if (chrome.runtime.lastError) {
+              reject(new Error(chrome.runtime.lastError.message));
+            } else {
+              resolve(results?.[0]);
+            }
+          });
         });
       }
-    });
+      throw new Error("No executeScript API available (need MV3 scripting permission)");
+    };
+    const trimmed = code.trim();
+    const wrappedCode = /^\s*return\b/.test(trimmed) ? trimmed : `try { return (${trimmed}); } catch(__e) { return { __hanzo_error: __e.message || String(__e) }; }`;
+    let result = await exec(wrappedCode);
+    if (result && typeof result === "object" && "__hanzo_error" in result) {
+      throw new Error(result.__hanzo_error);
+    }
+    const looksEmpty = result !== null && typeof result === "object" && Object.keys(result).length === 0 && !Array.isArray(result);
+    if (looksEmpty) {
+      const promiseWrapped = `return Promise.resolve((function(){ ${wrappedCode} })()).then(function(__v){
+        try { return JSON.parse(JSON.stringify(__v === undefined ? null : __v)); } catch(e) { return String(__v); }
+      });`;
+      result = await exec(promiseWrapped);
+      if (result && typeof result === "object" && "__hanzo_error" in result) {
+        throw new Error(result.__hanzo_error);
+      }
+    }
+    return result;
   }
 };
 export {