@hanzo/browser-extension 1.9.31 → 1.9.33

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

@@ -1,1317 +0,0 @@
-// src/browser-control.ts
-var BrowserControl = class {
-  constructor() {
-    this.tabFS = /* @__PURE__ */ new Map();
-    this.aiWorkers = /* @__PURE__ */ new Map();
-    this.agents = /* @__PURE__ */ new Map();
-    this.initializeTabFileSystem();
-    this.setupMessageHandlers();
-  }
-  initializeTabFileSystem() {
-    if (typeof chrome === "undefined" || !chrome.tabs) return;
-    chrome.tabs.query({}, (tabs) => {
-      tabs.forEach((tab, index) => {
-        if (tab.id && tab.url) {
-          const path = `/tabs/${index}/${this.sanitizePath(tab.title || "untitled")}`;
-          this.tabFS.set(path, {
-            path,
-            tabId: tab.id,
-            url: tab.url,
-            title: tab.title || "Untitled"
-          });
-        }
-      });
-    });
-    chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
-      if (changeInfo.status === "complete") {
-        this.updateTabFS(tab);
-      }
-    });
-    chrome.tabs.onRemoved.addListener((tabId) => {
-      for (const [path, entry] of this.tabFS) {
-        if (entry.tabId === tabId) {
-          this.tabFS.delete(path);
-          break;
-        }
-      }
-    });
-  }
-  sanitizePath(title) {
-    return title.replace(/[^a-zA-Z0-9-_]/g, "_").toLowerCase().substring(0, 60);
-  }
-  updateTabFS(tab) {
-    if (!tab.id || !tab.url) return;
-    const existingEntry = Array.from(this.tabFS.values()).find(
-      (entry) => entry.tabId === tab.id
-    );
-    const path = existingEntry?.path || `/tabs/${this.tabFS.size}/${this.sanitizePath(tab.title || "untitled")}`;
-    this.tabFS.set(path, {
-      path,
-      tabId: tab.id,
-      url: tab.url,
-      title: tab.title || "Untitled"
-    });
-  }
-  // ===========================================================================
-  // FUSE-like Tab Filesystem
-  // ===========================================================================
-  async readTab(path) {
-    const entry = this.tabFS.get(path);
-    if (!entry) throw new Error(`Tab not found: ${path}`);
-    return new Promise((resolve, reject) => {
-      chrome.tabs.sendMessage(entry.tabId, { action: "getContent" }, (response) => {
-        if (chrome.runtime.lastError) {
-          reject(new Error(chrome.runtime.lastError.message));
-        } else {
-          resolve(response?.content || "");
-        }
-      });
-    });
-  }
-  async writeTab(path, content) {
-    const entry = this.tabFS.get(path);
-    if (!entry) throw new Error(`Tab not found: ${path}`);
-    return new Promise((resolve, reject) => {
-      chrome.tabs.sendMessage(entry.tabId, { action: "setContent", content }, (response) => {
-        if (chrome.runtime.lastError) {
-          reject(new Error(chrome.runtime.lastError.message));
-        } else {
-          resolve();
-        }
-      });
-    });
-  }
-  async listTabs() {
-    return Array.from(this.tabFS.keys());
-  }
-  // ===========================================================================
-  // Native Browser Actions
-  // ===========================================================================
-  async click(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.scrollIntoView({ behavior: 'smooth', block: 'center' });
-        el.click();
-        return true;
-      })()
-    `);
-  }
-  async clickAtPoint(tabId, x, y) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.elementFromPoint(${x}, ${y});
-        if (!el) return false;
-        el.dispatchEvent(new MouseEvent('click', { bubbles: true, clientX: ${x}, clientY: ${y} }));
-        return true;
-      })()
-    `);
-  }
-  async doubleClick(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.scrollIntoView({ behavior: 'smooth', block: 'center' });
-        el.dispatchEvent(new MouseEvent('dblclick', { bubbles: true }));
-        return true;
-      })()
-    `);
-  }
-  async type(tabId, selector, text) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.focus();
-        for (const char of ${JSON.stringify(text)}) {
-          el.dispatchEvent(new KeyboardEvent('keydown', { key: char, bubbles: true }));
-          el.dispatchEvent(new KeyboardEvent('keypress', { key: char, bubbles: true }));
-          if ('value' in el) el.value += char;
-          el.dispatchEvent(new InputEvent('input', { data: char, inputType: 'insertText', bubbles: true }));
-          el.dispatchEvent(new KeyboardEvent('keyup', { key: char, bubbles: true }));
-        }
-        el.dispatchEvent(new Event('change', { bubbles: true }));
-        return true;
-      })()
-    `);
-  }
-  async fill(tabId, selector, value) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.focus();
-        const nativeSetter = Object.getOwnPropertyDescriptor(
-          Object.getPrototypeOf(el), 'value'
-        )?.set || Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
-        if (nativeSetter) {
-          nativeSetter.call(el, ${JSON.stringify(value)});
-        } else {
-          el.value = ${JSON.stringify(value)};
-        }
-        el.dispatchEvent(new Event('input', { bubbles: true }));
-        el.dispatchEvent(new Event('change', { bubbles: true }));
-        return true;
-      })()
-    `);
-  }
-  async select(tabId, selector, value) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el || el.tagName !== 'SELECT') return false;
-        el.value = ${JSON.stringify(value)};
-        el.dispatchEvent(new Event('change', { bubbles: true }));
-        return true;
-      })()
-    `);
-  }
-  async check(tabId, selector, checked) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        if (el.checked !== ${checked}) el.click();
-        return true;
-      })()
-    `);
-  }
-  async hover(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.dispatchEvent(new MouseEvent('mouseenter', { bubbles: true }));
-        el.dispatchEvent(new MouseEvent('mouseover', { bubbles: true }));
-        return true;
-      })()
-    `);
-  }
-  async focus(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.focus();
-        return true;
-      })()
-    `);
-  }
-  async blur(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.blur();
-        return true;
-      })()
-    `);
-  }
-  async scroll(tabId, x, y, selector) {
-    if (selector) {
-      return this.executeScript(tabId, `
-        (() => {
-          const el = document.querySelector(${JSON.stringify(selector)});
-          if (!el) return false;
-          el.scrollBy({ left: ${x}, top: ${y}, behavior: 'smooth' });
-          return true;
-        })()
-      `);
-    }
-    return this.executeScript(tabId, `
-      (() => { window.scrollBy({ left: ${x}, top: ${y}, behavior: 'smooth' }); return true; })()
-    `);
-  }
-  async scrollIntoView(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.scrollIntoView({ behavior: 'smooth', block: 'center', inline: 'nearest' });
-        return true;
-      })()
-    `);
-  }
-  async pressKey(tabId, key, modifiers = {}) {
-    return this.executeScript(tabId, `
-      (() => {
-        const opts = {
-          key: ${JSON.stringify(key)},
-          code: ${JSON.stringify(key)},
-          bubbles: true,
-          ctrlKey: ${!!modifiers.ctrl},
-          shiftKey: ${!!modifiers.shift},
-          altKey: ${!!modifiers.alt},
-          metaKey: ${!!modifiers.meta},
-        };
-        document.activeElement.dispatchEvent(new KeyboardEvent('keydown', opts));
-        document.activeElement.dispatchEvent(new KeyboardEvent('keypress', opts));
-        document.activeElement.dispatchEvent(new KeyboardEvent('keyup', opts));
-        return true;
-      })()
-    `);
-  }
-  async drag(tabId, fromSelector, toSelector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const from = document.querySelector(${JSON.stringify(fromSelector)});
-        const to = document.querySelector(${JSON.stringify(toSelector)});
-        if (!from || !to) return false;
-        const fromRect = from.getBoundingClientRect();
-        const toRect = to.getBoundingClientRect();
-        const fromX = fromRect.left + fromRect.width / 2;
-        const fromY = fromRect.top + fromRect.height / 2;
-        const toX = toRect.left + toRect.width / 2;
-        const toY = toRect.top + toRect.height / 2;
-        from.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, clientX: fromX, clientY: fromY }));
-        from.dispatchEvent(new MouseEvent('mousemove', { bubbles: true, clientX: toX, clientY: toY }));
-        to.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, clientX: toX, clientY: toY }));
-        to.dispatchEvent(new DragEvent('drop', { bubbles: true }));
-        return true;
-      })()
-    `);
-  }
-  async waitForSelector(tabId, selector, timeoutMs = 1e4) {
-    return this.executeScript(tabId, `
-      new Promise((resolve) => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (el) { resolve(true); return; }
-        const observer = new MutationObserver(() => {
-          if (document.querySelector(${JSON.stringify(selector)})) {
-            observer.disconnect();
-            resolve(true);
-          }
-        });
-        observer.observe(document.body, { childList: true, subtree: true });
-        setTimeout(() => { observer.disconnect(); resolve(false); }, ${timeoutMs});
-      })
-    `);
-  }
-  async waitForNavigation(tabId, timeoutMs = 3e4) {
-    return new Promise((resolve) => {
-      const timer = setTimeout(() => {
-        chrome.tabs.onUpdated.removeListener(listener);
-        resolve(false);
-      }, timeoutMs);
-      const listener = (updatedTabId, changeInfo) => {
-        if (updatedTabId === tabId && changeInfo.status === "complete") {
-          clearTimeout(timer);
-          chrome.tabs.onUpdated.removeListener(listener);
-          resolve(true);
-        }
-      };
-      chrome.tabs.onUpdated.addListener(listener);
-    });
-  }
-  async evaluate(tabId, expression) {
-    return this.executeScript(tabId, expression);
-  }
-  async getElementInfo(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return null;
-        const rect = el.getBoundingClientRect();
-        const styles = window.getComputedStyle(el);
-        return {
-          tagName: el.tagName.toLowerCase(),
-          id: el.id,
-          className: el.className,
-          textContent: el.textContent?.substring(0, 500),
-          innerText: el.innerText?.substring(0, 500),
-          value: el.value,
-          href: el.href,
-          src: el.src,
-          type: el.type,
-          checked: el.checked,
-          disabled: el.disabled,
-          visible: styles.display !== 'none' && styles.visibility !== 'hidden' && rect.width > 0 && rect.height > 0,
-          rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
-          attributes: Object.fromEntries(Array.from(el.attributes).map(a => [a.name, a.value])),
-        };
-      })()
-    `);
-  }
-  async getPageInfo(tabId) {
-    return this.executeScript(tabId, `
-      (() => ({
-        url: location.href,
-        title: document.title,
-        readyState: document.readyState,
-        scrollX: window.scrollX,
-        scrollY: window.scrollY,
-        innerWidth: window.innerWidth,
-        innerHeight: window.innerHeight,
-        documentWidth: document.documentElement.scrollWidth,
-        documentHeight: document.documentElement.scrollHeight,
-        forms: document.forms.length,
-        links: document.links.length,
-        images: document.images.length,
-      }))()
-    `);
-  }
-  async querySelectorAll(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => Array.from(document.querySelectorAll(${JSON.stringify(selector)})).slice(0, 100).map((el, i) => ({
-        index: i,
-        tagName: el.tagName.toLowerCase(),
-        id: el.id,
-        className: el.className,
-        textContent: el.textContent?.substring(0, 200),
-        visible: el.offsetWidth > 0 && el.offsetHeight > 0,
-      })))()
-    `);
-  }
-  // ===========================================================================
-  // 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) {
-    chrome.tabs.update(tabId, { url });
-  }
-  async reload(tabId) {
-    chrome.tabs.reload(tabId);
-  }
-  async goBack(tabId) {
-    chrome.tabs.goBack(tabId);
-  }
-  async goForward(tabId) {
-    chrome.tabs.goForward(tabId);
-  }
-  async createTab(url, active = true) {
-    return new Promise((resolve) => {
-      chrome.tabs.create({ url, active }, (tab) => {
-        resolve(tab.id);
-      });
-    });
-  }
-  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);
-  }
-  // ===========================================================================
-  // Screenshots
-  // ===========================================================================
-  async captureScreenshot(tabId, options) {
-    return new Promise((resolve, reject) => {
-      const format = options?.format || "jpeg";
-      const quality = options?.quality || (format === "jpeg" ? 80 : void 0);
-      const captureOpts = { format };
-      if (quality !== void 0) captureOpts.quality = quality;
-      chrome.tabs.captureVisibleTab(captureOpts, (dataUrl) => {
-        if (chrome.runtime.lastError) {
-          reject(new Error(chrome.runtime.lastError.message));
-        } else {
-          resolve(dataUrl);
-        }
-      });
-    });
-  }
-  async captureFullPage(tabId) {
-    const pageInfo = await this.getPageInfo(tabId);
-    return this.captureScreenshot(tabId, { format: "png" });
-  }
-  // ===========================================================================
-  // AI Worker Management
-  // ===========================================================================
-  async launchAIWorker(tabId, modelName) {
-    const worker = new Worker(new URL("./ai-worker.js", import.meta.url), {
-      type: "module"
-    });
-    const agentId = `agent-${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 8)}`;
-    worker.postMessage({ type: "init", payload: { tabId, modelName } });
-    worker.onmessage = (event) => {
-      this.handleAIWorkerMessage(tabId, agentId, event.data);
-    };
-    worker.onerror = (event) => {
-      console.error(`[Hanzo] AI worker error for tab ${tabId}:`, event.message);
-      const agent = this.agents.get(agentId);
-      if (agent) agent.status = "error";
-    };
-    this.aiWorkers.set(tabId, worker);
-    this.agents.set(agentId, {
-      id: agentId,
-      name: modelName,
-      tabId,
-      status: "running",
-      worker
-    });
-    return agentId;
-  }
-  stopAgent(agentId) {
-    const agent = this.agents.get(agentId);
-    if (!agent) return false;
-    agent.worker.terminate();
-    agent.status = "stopped";
-    this.aiWorkers.delete(agent.tabId);
-    this.agents.delete(agentId);
-    return true;
-  }
-  getAgents() {
-    return Array.from(this.agents.values()).map((a) => ({
-      id: a.id,
-      name: a.name,
-      tabId: a.tabId,
-      status: a.status
-    }));
-  }
-  handleAIWorkerMessage(tabId, agentId, data) {
-    switch (data.type) {
-      case "click":
-        this.click(tabId, data.selector);
-        break;
-      case "type":
-        this.type(tabId, data.selector, data.text);
-        break;
-      case "fill":
-        this.fill(tabId, data.selector, data.value);
-        break;
-      case "navigate":
-        this.navigateTo(tabId, data.url);
-        break;
-      case "scroll":
-        this.scroll(tabId, data.x || 0, data.y || 0, data.selector);
-        break;
-      case "hover":
-        this.hover(tabId, data.selector);
-        break;
-      case "select":
-        this.select(tabId, data.selector, data.value);
-        break;
-      case "pressKey":
-        this.pressKey(tabId, data.key, data.modifiers);
-        break;
-      case "waitForSelector":
-        this.waitForSelector(tabId, data.selector, data.timeout).then((found) => {
-          const worker = this.aiWorkers.get(tabId);
-          worker?.postMessage({ type: "waitResult", found });
-        });
-        break;
-      case "evaluate":
-        this.evaluate(tabId, data.expression).then((result) => {
-          const worker = this.aiWorkers.get(tabId);
-          worker?.postMessage({ type: "evalResult", result });
-        });
-        break;
-      case "screenshot":
-        this.captureScreenshot(tabId).then((screenshot) => {
-          const worker = this.aiWorkers.get(tabId);
-          worker?.postMessage({ type: "screenshot", data: screenshot });
-        });
-        break;
-      case "getElementInfo":
-        this.getElementInfo(tabId, data.selector).then((info) => {
-          const worker = this.aiWorkers.get(tabId);
-          worker?.postMessage({ type: "elementInfo", info });
-        });
-        break;
-      case "getPageInfo":
-        this.getPageInfo(tabId).then((info) => {
-          const worker = this.aiWorkers.get(tabId);
-          worker?.postMessage({ type: "pageInfo", info });
-        });
-        break;
-      case "querySelectorAll":
-        this.querySelectorAll(tabId, data.selector).then((elements) => {
-          const worker = this.aiWorkers.get(tabId);
-          worker?.postMessage({ type: "elements", elements });
-        });
-        break;
-      case "done":
-      case "complete": {
-        const agent = this.agents.get(agentId);
-        if (agent) {
-          agent.status = "stopped";
-          agent.worker.terminate();
-          this.aiWorkers.delete(tabId);
-          this.agents.delete(agentId);
-        }
-        break;
-      }
-    }
-  }
-  // ===========================================================================
-  // Cross-tab Communication
-  // ===========================================================================
-  async broadcastToAI(message) {
-    this.aiWorkers.forEach((worker) => {
-      worker.postMessage({ type: "broadcast", message });
-    });
-  }
-  // ===========================================================================
-  // Content Script Message Handler
-  // ===========================================================================
-  setupMessageHandlers() {
-    if (typeof chrome === "undefined" || !chrome.runtime) return;
-    chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
-      if (request.from === "content" && sender.tab?.id) {
-        this.handleContentMessage(sender.tab.id, request, sendResponse);
-        return true;
-      }
-      if (request.action?.startsWith("browser.")) {
-        this.handleBrowserAction(request, sendResponse);
-        return true;
-      }
-      if (request.action === "listAgents") {
-        sendResponse({ success: true, agents: this.getAgents() });
-        return true;
-      }
-      if (request.action === "stopAgent") {
-        const stopped = this.stopAgent(request.agentId);
-        sendResponse({ success: stopped });
-        return true;
-      }
-      if (request.action === "checkWebGPU") {
-        if (navigator.gpu) {
-          navigator.gpu.requestAdapter().then((adapter) => {
-            sendResponse({
-              available: !!adapter,
-              adapter: adapter?.name || "Unknown GPU"
-            });
-          }).catch(() => {
-            sendResponse({ available: false });
-          });
-        } else {
-          sendResponse({ available: false });
-        }
-        return true;
-      }
-    });
-  }
-  async handleBrowserAction(request, sendResponse) {
-    const tabId = request.tabId;
-    try {
-      switch (request.action) {
-        case "browser.click":
-          sendResponse({ success: await this.click(tabId, request.selector) });
-          break;
-        case "browser.type":
-          sendResponse({ success: await this.type(tabId, request.selector, request.text) });
-          break;
-        case "browser.fill":
-          sendResponse({ success: await this.fill(tabId, request.selector, request.value) });
-          break;
-        case "browser.select":
-          sendResponse({ success: await this.select(tabId, request.selector, request.value) });
-          break;
-        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;
-        case "browser.evaluate":
-          sendResponse({ success: true, result: await this.evaluate(tabId, request.expression) });
-          break;
-        case "browser.screenshot":
-          sendResponse({ success: true, data: await this.captureScreenshot(tabId, request.options) });
-          break;
-        case "browser.navigate":
-          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;
-        case "browser.getElementInfo":
-          sendResponse({ success: true, info: await this.getElementInfo(tabId, request.selector) });
-          break;
-        case "browser.getPageInfo":
-          sendResponse({ success: true, info: await this.getPageInfo(tabId) });
-          break;
-        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}` });
-      }
-    } catch (e) {
-      sendResponse({ success: false, error: e.message });
-    }
-  }
-  handleContentMessage(tabId, request, sendResponse) {
-    const worker = this.aiWorkers.get(tabId);
-    if (worker) {
-      worker.postMessage({ type: "contentMessage", data: request });
-      const responseHandler = (event) => {
-        if (event.data.type === "contentResponse") {
-          sendResponse(event.data.response);
-          worker.removeEventListener("message", responseHandler);
-        }
-      };
-      worker.addEventListener("message", responseHandler);
-      setTimeout(() => {
-        worker.removeEventListener("message", responseHandler);
-      }, 1e4);
-    } else {
-      sendResponse({ error: "No AI worker for this tab" });
-    }
-  }
-  // ===========================================================================
-  // Script Execution Helper
-  // ===========================================================================
-  /**
-   * 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 },
-          world: "MAIN",
-          args: [wrapped],
-          func: (codeStr) => {
-            try {
-              return Function(codeStr)();
-            } catch (e) {
-              return { __hanzo_error: e?.message || String(e) };
-            }
-          }
-        });
-        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 {
-  BrowserControl
-};