bb-browser 0.1.0

package/extension/dist/background.js

@@ -0,0 +1,2943 @@
+const DAEMON_PORT = 19824;
+const DAEMON_HOST = "localhost";
+const DAEMON_BASE_URL = `http://${DAEMON_HOST}:${DAEMON_PORT}`;
+const SSE_RECONNECT_DELAY = 3e3;
+const SSE_MAX_RECONNECT_ATTEMPTS = 5;
+
+class SSEClient {
+  constructor() {
+    this.abortController = null;
+    this.reconnectAttempts = 0;
+    this.isConnectedFlag = false;
+    this.onCommandHandler = null;
+  }
+  /**
+   * 连接到 Daemon SSE 端点
+   */
+  async connect() {
+    if (this.abortController) {
+      console.warn("[SSEClient] Already connected");
+      return;
+    }
+    const sseUrl = `${DAEMON_BASE_URL}/sse`;
+    console.log("[SSEClient] Connecting to:", sseUrl);
+    this.abortController = new AbortController();
+    try {
+      const response = await fetch(sseUrl, {
+        signal: this.abortController.signal,
+        headers: {
+          Accept: "text/event-stream",
+          "Cache-Control": "no-cache"
+        },
+        keepalive: true
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      if (!response.body) {
+        throw new Error("Response body is null");
+      }
+      const contentType = response.headers.get("Content-Type");
+      console.log("[SSEClient] Connection established, Content-Type:", contentType);
+      this.isConnectedFlag = true;
+      this.reconnectAttempts = 0;
+      await this.readStream(response.body);
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        console.log("[SSEClient] Connection aborted");
+        return;
+      }
+      console.error("[SSEClient] Connection error:", error);
+      this.isConnectedFlag = false;
+      this.reconnect();
+    }
+  }
+  /**
+   * 读取并解析 SSE 流
+   */
+  async readStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let event = "";
+    let data = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          console.log("[SSEClient] Stream ended");
+          this.isConnectedFlag = false;
+          this.reconnect();
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmedLine = line.trim();
+          if (trimmedLine.startsWith("event:")) {
+            event = trimmedLine.substring(6).trim();
+          } else if (trimmedLine.startsWith("data:")) {
+            data = trimmedLine.substring(5).trim();
+          } else if (trimmedLine === "") {
+            if (event && data) {
+              await this.handleMessage(event, data);
+              event = "";
+              data = "";
+            }
+          }
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        console.log("[SSEClient] Stream reading aborted");
+        return;
+      }
+      console.error("[SSEClient] Stream reading error:", error);
+      this.isConnectedFlag = false;
+      this.reconnect();
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * 处理 SSE 消息
+   */
+  async handleMessage(event, data) {
+    try {
+      const parsed = JSON.parse(data);
+      switch (event) {
+        case "connected":
+          console.log("[SSEClient] Connection confirmed:", parsed);
+          break;
+        case "heartbeat":
+          console.log("[SSEClient] Heartbeat:", new Date(parsed.time * 1e3).toISOString());
+          break;
+        case "command":
+          console.log("[SSEClient] Command received:", parsed.id, parsed.action);
+          if (this.onCommandHandler) {
+            await this.onCommandHandler(parsed);
+          } else {
+            console.warn("[SSEClient] No command handler registered");
+          }
+          break;
+        default:
+          console.log("[SSEClient] Unknown event type:", event);
+      }
+    } catch (error) {
+      console.error("[SSEClient] Error handling message:", error);
+    }
+  }
+  /**
+   * 指数退避重连
+   */
+  reconnect() {
+    if (this.reconnectAttempts >= SSE_MAX_RECONNECT_ATTEMPTS) {
+      console.error("[SSEClient] Max reconnection attempts reached");
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = SSE_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts - 1);
+    console.log(
+      `[SSEClient] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${SSE_MAX_RECONNECT_ATTEMPTS})`
+    );
+    setTimeout(() => {
+      this.disconnect();
+      this.connect();
+    }, delay);
+  }
+  /**
+   * 注册命令处理器
+   */
+  onCommand(handler) {
+    this.onCommandHandler = handler;
+  }
+  /**
+   * 断开连接
+   */
+  disconnect() {
+    if (this.abortController) {
+      console.log("[SSEClient] Disconnecting...");
+      this.abortController.abort();
+      this.abortController = null;
+      this.isConnectedFlag = false;
+    }
+  }
+  /**
+   * 检查连接状态
+   */
+  isConnected() {
+    return this.isConnectedFlag;
+  }
+}
+
+async function sendResult(result) {
+  const url = `${DAEMON_BASE_URL}/result`;
+  console.log("[APIClient] Sending result:", result.id, result.success);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(result)
+    });
+    if (!response.ok) {
+      console.error("[APIClient] Failed to send result:", response.status, response.statusText);
+      return;
+    }
+    const data = await response.json();
+    console.log("[APIClient] Result sent successfully:", data);
+  } catch (error) {
+    console.error("[APIClient] Error sending result:", error);
+  }
+}
+
+const attachedTabs = /* @__PURE__ */ new Set();
+const pendingDialogs = /* @__PURE__ */ new Map();
+const networkRequests = /* @__PURE__ */ new Map();
+const consoleMessages = /* @__PURE__ */ new Map();
+const jsErrors = /* @__PURE__ */ new Map();
+const networkRoutes = /* @__PURE__ */ new Map();
+const networkEnabledTabs = /* @__PURE__ */ new Set();
+const MAX_REQUESTS = 500;
+const MAX_CONSOLE_MESSAGES = 500;
+const MAX_ERRORS = 100;
+async function ensureAttached(tabId) {
+  if (attachedTabs.has(tabId)) {
+    return;
+  }
+  try {
+    await chrome.debugger.attach({ tabId }, "1.3");
+    attachedTabs.add(tabId);
+    await chrome.debugger.sendCommand({ tabId }, "Page.enable");
+    await chrome.debugger.sendCommand({ tabId }, "DOM.enable");
+    await chrome.debugger.sendCommand({ tabId }, "Runtime.enable");
+    console.log("[CDPService] Attached to tab:", tabId);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (msg.includes("Another debugger is already attached")) {
+      attachedTabs.add(tabId);
+      return;
+    }
+    throw error;
+  }
+}
+async function sendCommand(tabId, method, params) {
+  await ensureAttached(tabId);
+  const result = await chrome.debugger.sendCommand({ tabId }, method, params);
+  return result;
+}
+async function evaluate(tabId, expression, options = {}) {
+  const result = await sendCommand(tabId, "Runtime.evaluate", {
+    expression,
+    returnByValue: options.returnByValue ?? true,
+    awaitPromise: options.awaitPromise ?? true
+  });
+  if (result.exceptionDetails) {
+    const errorMsg = result.exceptionDetails.exception?.description || result.exceptionDetails.text || "Unknown error";
+    throw new Error(`Eval error: ${errorMsg}`);
+  }
+  return result.result?.value;
+}
+async function dispatchMouseEvent(tabId, type, x, y, options = {}) {
+  await sendCommand(tabId, "Input.dispatchMouseEvent", {
+    type,
+    x,
+    y,
+    button: options.button ?? "left",
+    clickCount: options.clickCount ?? 1,
+    deltaX: options.deltaX ?? 0,
+    deltaY: options.deltaY ?? 0,
+    modifiers: options.modifiers ?? 0
+  });
+}
+async function click(tabId, x, y) {
+  await dispatchMouseEvent(tabId, "mousePressed", x, y, { button: "left", clickCount: 1 });
+  await dispatchMouseEvent(tabId, "mouseReleased", x, y, { button: "left", clickCount: 1 });
+}
+async function moveMouse(tabId, x, y) {
+  await dispatchMouseEvent(tabId, "mouseMoved", x, y);
+}
+async function scroll(tabId, x, y, deltaX, deltaY) {
+  await dispatchMouseEvent(tabId, "mouseWheel", x, y, { deltaX, deltaY });
+}
+async function dispatchKeyEvent(tabId, type, options = {}) {
+  await sendCommand(tabId, "Input.dispatchKeyEvent", {
+    type,
+    ...options
+  });
+}
+async function pressKey$1(tabId, key, options = {}) {
+  const keyCodeMap = {
+    Enter: 13,
+    Tab: 9,
+    Backspace: 8,
+    Escape: 27,
+    ArrowUp: 38,
+    ArrowDown: 40,
+    ArrowLeft: 37,
+    ArrowRight: 39,
+    Delete: 46,
+    Home: 36,
+    End: 35,
+    PageUp: 33,
+    PageDown: 34
+  };
+  const keyCode = keyCodeMap[key] || key.charCodeAt(0);
+  await dispatchKeyEvent(tabId, "rawKeyDown", {
+    key,
+    code: key,
+    windowsVirtualKeyCode: keyCode,
+    nativeVirtualKeyCode: keyCode,
+    modifiers: options.modifiers
+  });
+  if (key.length === 1) {
+    await dispatchKeyEvent(tabId, "char", {
+      text: key,
+      key,
+      modifiers: options.modifiers
+    });
+  }
+  await dispatchKeyEvent(tabId, "keyUp", {
+    key,
+    code: key,
+    windowsVirtualKeyCode: keyCode,
+    nativeVirtualKeyCode: keyCode,
+    modifiers: options.modifiers
+  });
+}
+async function insertText(tabId, text) {
+  await sendCommand(tabId, "Input.insertText", { text });
+}
+async function handleJavaScriptDialog(tabId, accept, promptText) {
+  await sendCommand(tabId, "Page.handleJavaScriptDialog", {
+    accept,
+    promptText
+  });
+}
+function getPendingDialog(tabId) {
+  return pendingDialogs.get(tabId);
+}
+async function enableNetwork(tabId) {
+  if (networkEnabledTabs.has(tabId)) return;
+  await ensureAttached(tabId);
+  await sendCommand(tabId, "Network.enable");
+  await sendCommand(tabId, "Fetch.enable", {
+    patterns: [{ urlPattern: "*" }]
+  });
+  networkEnabledTabs.add(tabId);
+  if (!networkRequests.has(tabId)) {
+    networkRequests.set(tabId, []);
+  }
+  console.log("[CDPService] Network enabled for tab:", tabId);
+}
+function getNetworkRequests(tabId, filter) {
+  const requests = networkRequests.get(tabId) || [];
+  if (!filter) return requests;
+  const lowerFilter = filter.toLowerCase();
+  return requests.filter(
+    (r) => r.url.toLowerCase().includes(lowerFilter) || r.method.toLowerCase().includes(lowerFilter) || r.type.toLowerCase().includes(lowerFilter)
+  );
+}
+function clearNetworkRequests(tabId) {
+  networkRequests.set(tabId, []);
+}
+async function addNetworkRoute(tabId, urlPattern, options = {}) {
+  await enableNetwork(tabId);
+  const route = {
+    urlPattern,
+    action: options.abort ? "abort" : options.body ? "fulfill" : "continue",
+    body: options.body,
+    status: options.status ?? 200,
+    headers: options.headers
+  };
+  const routes = networkRoutes.get(tabId) || [];
+  const filtered = routes.filter((r) => r.urlPattern !== urlPattern);
+  filtered.push(route);
+  networkRoutes.set(tabId, filtered);
+  console.log("[CDPService] Added network route:", route);
+}
+function removeNetworkRoute(tabId, urlPattern) {
+  if (!urlPattern) {
+    networkRoutes.delete(tabId);
+    console.log("[CDPService] Removed all network routes for tab:", tabId);
+  } else {
+    const routes = networkRoutes.get(tabId) || [];
+    networkRoutes.set(tabId, routes.filter((r) => r.urlPattern !== urlPattern));
+    console.log("[CDPService] Removed network route:", urlPattern);
+  }
+}
+function getNetworkRoutes(tabId) {
+  return networkRoutes.get(tabId) || [];
+}
+async function enableConsole(tabId) {
+  await ensureAttached(tabId);
+  await sendCommand(tabId, "Runtime.enable");
+  await sendCommand(tabId, "Log.enable");
+  if (!consoleMessages.has(tabId)) {
+    consoleMessages.set(tabId, []);
+  }
+  if (!jsErrors.has(tabId)) {
+    jsErrors.set(tabId, []);
+  }
+  console.log("[CDPService] Console enabled for tab:", tabId);
+}
+function getConsoleMessages(tabId) {
+  return consoleMessages.get(tabId) || [];
+}
+function clearConsoleMessages(tabId) {
+  consoleMessages.set(tabId, []);
+}
+function getJSErrors(tabId) {
+  return jsErrors.get(tabId) || [];
+}
+function clearJSErrors(tabId) {
+  jsErrors.set(tabId, []);
+}
+function initEventListeners() {
+  chrome.debugger.onEvent.addListener((source, method, params) => {
+    const tabId = source.tabId;
+    if (!tabId) return;
+    if (method === "Page.javascriptDialogOpening") {
+      const dialogParams = params;
+      console.log("[CDPService] Dialog opened:", dialogParams);
+      pendingDialogs.set(tabId, dialogParams);
+    } else if (method === "Page.javascriptDialogClosed") {
+      console.log("[CDPService] Dialog closed");
+      pendingDialogs.delete(tabId);
+    } else if (method === "Network.requestWillBeSent") {
+      handleNetworkRequest(tabId, params);
+    } else if (method === "Network.responseReceived") {
+      handleNetworkResponse(tabId, params);
+    } else if (method === "Network.loadingFailed") {
+      handleNetworkFailed(tabId, params);
+    } else if (method === "Fetch.requestPaused") {
+      handleFetchPaused(tabId, params);
+    } else if (method === "Runtime.consoleAPICalled") {
+      handleConsoleAPI(tabId, params);
+    } else if (method === "Log.entryAdded") {
+      handleLogEntry(tabId, params);
+    } else if (method === "Runtime.exceptionThrown") {
+      handleException(tabId, params);
+    }
+  });
+  chrome.debugger.onDetach.addListener((source) => {
+    if (source.tabId) {
+      cleanupTab(source.tabId);
+      console.log("[CDPService] Debugger detached from tab:", source.tabId);
+    }
+  });
+  chrome.tabs.onRemoved.addListener((tabId) => {
+    cleanupTab(tabId);
+  });
+}
+function cleanupTab(tabId) {
+  attachedTabs.delete(tabId);
+  pendingDialogs.delete(tabId);
+  networkRequests.delete(tabId);
+  networkRoutes.delete(tabId);
+  networkEnabledTabs.delete(tabId);
+  consoleMessages.delete(tabId);
+  jsErrors.delete(tabId);
+}
+function handleNetworkRequest(tabId, params) {
+  const requests = networkRequests.get(tabId) || [];
+  if (requests.length >= MAX_REQUESTS) {
+    requests.shift();
+  }
+  requests.push({
+    requestId: params.requestId,
+    url: params.request.url,
+    method: params.request.method,
+    type: params.type,
+    timestamp: params.timestamp * 1e3,
+    headers: params.request.headers,
+    postData: params.request.postData
+  });
+  networkRequests.set(tabId, requests);
+}
+function handleNetworkResponse(tabId, params) {
+  const requests = networkRequests.get(tabId) || [];
+  const request = requests.find((r) => r.requestId === params.requestId);
+  if (request) {
+    request.response = {
+      status: params.response.status,
+      statusText: params.response.statusText,
+      headers: params.response.headers,
+      mimeType: params.response.mimeType
+    };
+  }
+}
+function handleNetworkFailed(tabId, params) {
+  const requests = networkRequests.get(tabId) || [];
+  const request = requests.find((r) => r.requestId === params.requestId);
+  if (request) {
+    request.failed = true;
+    request.failureReason = params.errorText;
+  }
+}
+async function handleFetchPaused(tabId, params) {
+  const routes = networkRoutes.get(tabId) || [];
+  const url = params.request.url;
+  const matchedRoute = routes.find((route) => {
+    if (route.urlPattern === "*") return true;
+    if (route.urlPattern.includes("*")) {
+      const regex = new RegExp(route.urlPattern.replace(/\*/g, ".*"));
+      return regex.test(url);
+    }
+    return url.includes(route.urlPattern);
+  });
+  try {
+    if (matchedRoute) {
+      if (matchedRoute.action === "abort") {
+        await sendCommand(tabId, "Fetch.failRequest", {
+          requestId: params.requestId,
+          errorReason: "BlockedByClient"
+        });
+        console.log("[CDPService] Blocked request:", url);
+      } else if (matchedRoute.action === "fulfill") {
+        await sendCommand(tabId, "Fetch.fulfillRequest", {
+          requestId: params.requestId,
+          responseCode: matchedRoute.status || 200,
+          responseHeaders: Object.entries(matchedRoute.headers || {}).map(([name, value]) => ({ name, value })),
+          body: matchedRoute.body ? btoa(matchedRoute.body) : void 0
+        });
+        console.log("[CDPService] Fulfilled request with mock:", url);
+      } else {
+        await sendCommand(tabId, "Fetch.continueRequest", {
+          requestId: params.requestId
+        });
+      }
+    } else {
+      await sendCommand(tabId, "Fetch.continueRequest", {
+        requestId: params.requestId
+      });
+    }
+  } catch (error) {
+    console.error("[CDPService] Fetch handling error:", error);
+    try {
+      await sendCommand(tabId, "Fetch.continueRequest", {
+        requestId: params.requestId
+      });
+    } catch {
+    }
+  }
+}
+function handleConsoleAPI(tabId, params) {
+  const messages = consoleMessages.get(tabId) || [];
+  if (messages.length >= MAX_CONSOLE_MESSAGES) {
+    messages.shift();
+  }
+  const text = params.args.map((arg) => arg.value !== void 0 ? String(arg.value) : arg.description || "").join(" ");
+  const typeMap = {
+    log: "log",
+    info: "info",
+    warning: "warn",
+    error: "error",
+    debug: "debug"
+  };
+  messages.push({
+    type: typeMap[params.type] || "log",
+    text,
+    timestamp: params.timestamp,
+    url: params.stackTrace?.callFrames[0]?.url,
+    lineNumber: params.stackTrace?.callFrames[0]?.lineNumber
+  });
+  consoleMessages.set(tabId, messages);
+}
+function handleLogEntry(tabId, params) {
+  const messages = consoleMessages.get(tabId) || [];
+  if (messages.length >= MAX_CONSOLE_MESSAGES) {
+    messages.shift();
+  }
+  const typeMap = {
+    verbose: "debug",
+    info: "info",
+    warning: "warn",
+    error: "error"
+  };
+  messages.push({
+    type: typeMap[params.entry.level] || "log",
+    text: params.entry.text,
+    timestamp: params.entry.timestamp,
+    url: params.entry.url,
+    lineNumber: params.entry.lineNumber
+  });
+  consoleMessages.set(tabId, messages);
+}
+function handleException(tabId, params) {
+  const errors = jsErrors.get(tabId) || [];
+  if (errors.length >= MAX_ERRORS) {
+    errors.shift();
+  }
+  const details = params.exceptionDetails;
+  const stackTrace = details.stackTrace?.callFrames.map((f) => `  at ${f.url}:${f.lineNumber}:${f.columnNumber}`).join("\n");
+  errors.push({
+    message: details.exception?.description || details.text,
+    url: details.url,
+    lineNumber: details.lineNumber,
+    columnNumber: details.columnNumber,
+    stackTrace,
+    timestamp: params.timestamp
+  });
+  jsErrors.set(tabId, errors);
+}
+
+async function getSnapshot$1(tabId, options = {}) {
+  const { interactive = false } = options;
+  console.log("[DOMService] Getting snapshot for tab:", tabId, { interactive });
+  await injectBuildDomTreeScript(tabId);
+  const domTreeResult = await executeBuildDomTree(tabId);
+  const snapshotResult = interactive ? convertToAccessibilityTree(domTreeResult) : convertToFullTree(domTreeResult);
+  snapshotResult.refs;
+  console.log("[DOMService] Snapshot complete:", {
+    mode: interactive ? "interactive" : "full",
+    linesCount: snapshotResult.snapshot.split("\n").length,
+    refsCount: Object.keys(snapshotResult.refs).length
+  });
+  return snapshotResult;
+}
+function getFrameTarget(tabId) {
+  return { tabId };
+}
+async function injectBuildDomTreeScript(tabId) {
+  try {
+    const target = getFrameTarget(tabId);
+    const checkResults = await chrome.scripting.executeScript({
+      target,
+      func: () => Object.prototype.hasOwnProperty.call(window, "buildDomTree")
+    });
+    const isInjected = checkResults[0]?.result;
+    if (isInjected) {
+      return;
+    }
+    await chrome.scripting.executeScript({
+      target,
+      files: ["buildDomTree.js"]
+    });
+  } catch (error) {
+    console.error("[DOMService] Failed to inject buildDomTree script:", error);
+    throw new Error(`Failed to inject script: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function executeBuildDomTree(tabId) {
+  const target = getFrameTarget(tabId);
+  const results = await chrome.scripting.executeScript({
+    target,
+    func: (args) => {
+      return window.buildDomTree(args);
+    },
+    args: [{
+      showHighlightElements: true,
+      focusHighlightIndex: -1,
+      viewportExpansion: -1,
+      // -1 = 全页面模式，不限制视口
+      debugMode: false,
+      startId: 0,
+      startHighlightIndex: 0
+    }]
+  });
+  const result = results[0]?.result;
+  if (!result || !result.map || !result.rootId) {
+    throw new Error("Failed to build DOM tree: invalid result structure");
+  }
+  return result;
+}
+function getRole(node) {
+  const tagName = node.tagName.toLowerCase();
+  const role = node.attributes?.role;
+  if (role) return role;
+  const roleMap = {
+    a: "link",
+    button: "button",
+    input: getInputRole(node),
+    select: "combobox",
+    textarea: "textbox",
+    img: "image",
+    nav: "navigation",
+    main: "main",
+    header: "banner",
+    footer: "contentinfo",
+    aside: "complementary",
+    form: "form",
+    table: "table",
+    ul: "list",
+    ol: "list",
+    li: "listitem",
+    h1: "heading",
+    h2: "heading",
+    h3: "heading",
+    h4: "heading",
+    h5: "heading",
+    h6: "heading",
+    dialog: "dialog",
+    article: "article",
+    section: "region",
+    label: "label",
+    details: "group",
+    summary: "button"
+  };
+  return roleMap[tagName] || tagName;
+}
+function getInputRole(node) {
+  const type = node.attributes?.type?.toLowerCase() || "text";
+  const inputRoleMap = {
+    text: "textbox",
+    password: "textbox",
+    email: "textbox",
+    url: "textbox",
+    tel: "textbox",
+    search: "searchbox",
+    number: "spinbutton",
+    range: "slider",
+    checkbox: "checkbox",
+    radio: "radio",
+    button: "button",
+    submit: "button",
+    reset: "button",
+    file: "button"
+  };
+  return inputRoleMap[type] || "textbox";
+}
+function getAccessibleName(node, nodeMap) {
+  const attrs = node.attributes || {};
+  if (attrs["aria-label"]) return attrs["aria-label"];
+  if (attrs.title) return attrs.title;
+  if (attrs.placeholder) return attrs.placeholder;
+  if (attrs.alt) return attrs.alt;
+  if (attrs.value) return attrs.value;
+  const textContent = collectTextContent(node, nodeMap);
+  if (textContent) return textContent;
+  if (attrs.name) return attrs.name;
+  return void 0;
+}
+function collectTextContent(node, nodeMap, maxDepth = 5) {
+  const texts = [];
+  function collect(nodeId, depth) {
+    if (depth > maxDepth) return;
+    const currentNode = nodeMap[nodeId];
+    if (!currentNode) return;
+    if ("type" in currentNode && currentNode.type === "TEXT_NODE") {
+      const text = currentNode.text.trim();
+      if (text) texts.push(text);
+      return;
+    }
+    const elementNode = currentNode;
+    for (const childId of elementNode.children || []) {
+      collect(childId, depth + 1);
+    }
+  }
+  for (const childId of node.children || []) {
+    collect(childId, 0);
+  }
+  return texts.join(" ").trim();
+}
+function truncateText(text, maxLength = 50) {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength - 3) + "...";
+}
+function isAncestor(ancestorId, descendantId, nodeMap) {
+  const descendant = nodeMap[descendantId];
+  if (!descendant || "type" in descendant) return false;
+  const ancestor = nodeMap[ancestorId];
+  if (!ancestor || "type" in ancestor) return false;
+  const ancestorElement = ancestor;
+  const elementNode = descendant;
+  if (!ancestorElement.xpath || !elementNode.xpath) return false;
+  return elementNode.xpath.startsWith(ancestorElement.xpath + "/");
+}
+function convertToAccessibilityTree(result) {
+  const lines = [];
+  const refs = {};
+  const { map } = result;
+  const interactiveNodes = [];
+  for (const [id, node] of Object.entries(map)) {
+    if (!node) continue;
+    if ("type" in node && node.type === "TEXT_NODE") continue;
+    const elementNode = node;
+    if (elementNode.highlightIndex !== void 0 && elementNode.highlightIndex !== null) {
+      interactiveNodes.push({ id, node: elementNode });
+    }
+  }
+  interactiveNodes.sort((a, b) => (a.node.highlightIndex ?? 0) - (b.node.highlightIndex ?? 0));
+  const nodeIdToInfo = /* @__PURE__ */ new Map();
+  for (const { id, node } of interactiveNodes) {
+    nodeIdToInfo.set(id, {
+      name: getAccessibleName(node, map),
+      role: getRole(node)
+    });
+  }
+  const nonSemanticTags = /* @__PURE__ */ new Set(["span", "div", "i", "b", "em", "strong", "small", "svg", "path", "g"]);
+  const filterableTags = /* @__PURE__ */ new Set(["label"]);
+  const filteredNodes = [];
+  for (const item of interactiveNodes) {
+    const { id, node } = item;
+    const info = nodeIdToInfo.get(id);
+    const tagName = node.tagName.toLowerCase();
+    if ((nonSemanticTags.has(tagName) || tagName === "a") && !info.name) continue;
+    if (filterableTags.has(tagName)) continue;
+    let isChildOfInteractive = false;
+    for (const otherItem of interactiveNodes) {
+      if (otherItem.id === id) continue;
+      const otherTagName = otherItem.node.tagName.toLowerCase();
+      if (["a", "button"].includes(otherTagName) && nonSemanticTags.has(tagName) && isAncestor(otherItem.id, id, map)) {
+        isChildOfInteractive = true;
+        break;
+      }
+    }
+    if (isChildOfInteractive) continue;
+    let isDuplicate = false;
+    for (const otherItem of interactiveNodes) {
+      if (otherItem.id === id) continue;
+      const otherInfo = nodeIdToInfo.get(otherItem.id);
+      if (isAncestor(otherItem.id, id, map) && info.name && otherInfo.name && info.name === otherInfo.name) {
+        isDuplicate = true;
+        break;
+      }
+    }
+    if (!isDuplicate) filteredNodes.push(item);
+  }
+  for (const { id, node } of filteredNodes) {
+    const refId = String(node.highlightIndex);
+    const info = nodeIdToInfo.get(id);
+    let line = `- ${info.role}`;
+    if (info.name) line += ` "${truncateText(info.name)}"`;
+    line += ` [ref=${refId}]`;
+    lines.push(line);
+    refs[refId] = {
+      xpath: node.xpath || "",
+      role: info.role,
+      name: info.name ? truncateText(info.name, 100) : void 0,
+      tagName: node.tagName
+    };
+  }
+  return { snapshot: lines.join("\n"), refs };
+}
+function convertToFullTree(result) {
+  const lines = [];
+  const refs = {};
+  const { rootId, map } = result;
+  const skipTags = /* @__PURE__ */ new Set([
+    "script",
+    "style",
+    "noscript",
+    "svg",
+    "path",
+    "g",
+    "defs",
+    "clippath",
+    "lineargradient",
+    "stop",
+    "symbol",
+    "use",
+    "meta",
+    "link",
+    "head"
+  ]);
+  function traverse(nodeId, depth) {
+    const node = map[nodeId];
+    if (!node) return;
+    const indent = "  ".repeat(depth);
+    if ("type" in node && node.type === "TEXT_NODE") {
+      if (!node.isVisible) return;
+      const text = node.text.trim();
+      if (!text) return;
+      const displayText = text.length > 100 ? text.slice(0, 97) + "..." : text;
+      lines.push(`${indent}- text: ${displayText}`);
+      return;
+    }
+    const elementNode = node;
+    const tagName = elementNode.tagName.toLowerCase();
+    if (elementNode.isVisible === false) return;
+    if (skipTags.has(tagName)) return;
+    const role = getRole(elementNode);
+    const name = getAccessibleName(elementNode, map);
+    const hasRef = elementNode.highlightIndex !== void 0 && elementNode.highlightIndex !== null;
+    let line = `${indent}- ${role}`;
+    if (name) {
+      const displayName = name.length > 50 ? name.slice(0, 47) + "..." : name;
+      line += ` "${displayName}"`;
+    }
+    if (hasRef) {
+      const refId = String(elementNode.highlightIndex);
+      line += ` [ref=${refId}]`;
+      refs[refId] = {
+        xpath: elementNode.xpath || "",
+        role,
+        name: name ? name.length > 100 ? name.slice(0, 97) + "..." : name : void 0,
+        tagName: elementNode.tagName
+      };
+    }
+    lines.push(line);
+    for (const childId of elementNode.children || []) {
+      traverse(childId, depth + 1);
+    }
+  }
+  const rootNode = map[rootId];
+  if (rootNode && !("type" in rootNode)) {
+    for (const childId of rootNode.children || []) {
+      traverse(childId, 0);
+    }
+  }
+  return { snapshot: lines.join("\n"), refs };
+}
+
+let lastSnapshotRefs = {};
+async function loadRefsFromStorage() {
+  try {
+    const result = await chrome.storage.session.get("snapshotRefs");
+    if (result.snapshotRefs) {
+      lastSnapshotRefs = result.snapshotRefs;
+      console.log("[CDPDOMService] Loaded refs from storage:", Object.keys(lastSnapshotRefs).length);
+    }
+  } catch (e) {
+    console.warn("[CDPDOMService] Failed to load refs from storage:", e);
+  }
+}
+async function saveRefsToStorage(refs) {
+  try {
+    await chrome.storage.session.set({ snapshotRefs: refs });
+    console.log("[CDPDOMService] Saved refs to storage:", Object.keys(refs).length);
+  } catch (e) {
+    console.warn("[CDPDOMService] Failed to save refs to storage:", e);
+  }
+}
+loadRefsFromStorage();
+async function getSnapshot(tabId, options = {}) {
+  console.log("[CDPDOMService] Getting snapshot via legacy method for tab:", tabId);
+  const result = await getSnapshot$1(tabId, options);
+  const convertedRefs = {};
+  for (const [refId, refInfo] of Object.entries(result.refs)) {
+    convertedRefs[refId] = {
+      xpath: refInfo.xpath,
+      role: refInfo.role,
+      name: refInfo.name,
+      tagName: refInfo.tagName
+    };
+  }
+  lastSnapshotRefs = convertedRefs;
+  await saveRefsToStorage(convertedRefs);
+  console.log("[CDPDOMService] Snapshot complete:", {
+    linesCount: result.snapshot.split("\n").length,
+    refsCount: Object.keys(convertedRefs).length
+  });
+  return {
+    snapshot: result.snapshot,
+    refs: convertedRefs
+  };
+}
+async function getRefInfo(ref) {
+  const refId = ref.startsWith("@") ? ref.slice(1) : ref;
+  if (lastSnapshotRefs[refId]) {
+    return lastSnapshotRefs[refId];
+  }
+  if (Object.keys(lastSnapshotRefs).length === 0) {
+    await loadRefsFromStorage();
+  }
+  return lastSnapshotRefs[refId] || null;
+}
+async function getElementCenterByXPath(tabId, xpath) {
+  const result = await evaluate(tabId, `
+    (function() {
+      const result = document.evaluate(
+        ${JSON.stringify(xpath)},
+        document,
+        null,
+        XPathResult.FIRST_ORDERED_NODE_TYPE,
+        null
+      );
+      const element = result.singleNodeValue;
+      if (!element) return null;
+      
+      // 滚动到可见
+      element.scrollIntoView({ behavior: 'auto', block: 'center', inline: 'center' });
+      
+      const rect = element.getBoundingClientRect();
+      return {
+        x: rect.left + rect.width / 2,
+        y: rect.top + rect.height / 2,
+      };
+    })()
+  `, { returnByValue: true });
+  if (!result) {
+    throw new Error(`Element not found by xpath: ${xpath}`);
+  }
+  return result;
+}
+async function clickElement(tabId, ref) {
+  const refInfo = await getRefInfo(ref);
+  if (!refInfo) {
+    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  }
+  const { xpath, role, name } = refInfo;
+  const { x, y } = await getElementCenterByXPath(tabId, xpath);
+  await click(tabId, x, y);
+  console.log("[CDPDOMService] Clicked element:", { ref, role, name, x, y });
+  return { role, name };
+}
+async function hoverElement(tabId, ref) {
+  const refInfo = await getRefInfo(ref);
+  if (!refInfo) {
+    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  }
+  const { xpath, role, name } = refInfo;
+  const { x, y } = await getElementCenterByXPath(tabId, xpath);
+  await moveMouse(tabId, x, y);
+  console.log("[CDPDOMService] Hovered element:", { ref, role, name, x, y });
+  return { role, name };
+}
+async function fillElement(tabId, ref, text) {
+  const refInfo = await getRefInfo(ref);
+  if (!refInfo) {
+    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  }
+  const { xpath, role, name } = refInfo;
+  await evaluate(tabId, `
+    (function() {
+      const result = document.evaluate(
+        ${JSON.stringify(xpath)},
+        document,
+        null,
+        XPathResult.FIRST_ORDERED_NODE_TYPE,
+        null
+      );
+      const element = result.singleNodeValue;
+      if (!element) throw new Error('Element not found');
+      
+      element.scrollIntoView({ behavior: 'auto', block: 'center', inline: 'center' });
+      element.focus();
+      
+      // 清空内容
+      if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
+        element.value = '';
+      } else if (element.isContentEditable) {
+        element.textContent = '';
+      }
+    })()
+  `);
+  await insertText(tabId, text);
+  console.log("[CDPDOMService] Filled element:", { ref, role, name, textLength: text.length });
+  return { role, name };
+}
+async function typeElement(tabId, ref, text) {
+  const refInfo = await getRefInfo(ref);
+  if (!refInfo) {
+    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  }
+  const { xpath, role, name } = refInfo;
+  await evaluate(tabId, `
+    (function() {
+      const result = document.evaluate(
+        ${JSON.stringify(xpath)},
+        document,
+        null,
+        XPathResult.FIRST_ORDERED_NODE_TYPE,
+        null
+      );
+      const element = result.singleNodeValue;
+      if (!element) throw new Error('Element not found');
+      
+      element.scrollIntoView({ behavior: 'auto', block: 'center', inline: 'center' });
+      element.focus();
+    })()
+  `);
+  for (const char of text) {
+    await pressKey$1(tabId, char);
+  }
+  console.log("[CDPDOMService] Typed in element:", { ref, role, name, textLength: text.length });
+  return { role, name };
+}
+async function getElementText(tabId, ref) {
+  const refInfo = await getRefInfo(ref);
+  if (!refInfo) {
+    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  }
+  const { xpath } = refInfo;
+  const text = await evaluate(tabId, `
+    (function() {
+      const result = document.evaluate(
+        ${JSON.stringify(xpath)},
+        document,
+        null,
+        XPathResult.FIRST_ORDERED_NODE_TYPE,
+        null
+      );
+      const element = result.singleNodeValue;
+      if (!element) return '';
+      return (element.textContent || '').trim();
+    })()
+  `);
+  console.log("[CDPDOMService] Got element text:", { ref, textLength: text.length });
+  return text;
+}
+async function checkElement(tabId, ref) {
+  const refInfo = await getRefInfo(ref);
+  if (!refInfo) {
+    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  }
+  const { xpath, role, name } = refInfo;
+  const result = await evaluate(tabId, `
+    (function() {
+      const result = document.evaluate(
+        ${JSON.stringify(xpath)},
+        document,
+        null,
+        XPathResult.FIRST_ORDERED_NODE_TYPE,
+        null
+      );
+      const element = result.singleNodeValue;
+      if (!element) throw new Error('Element not found');
+      if (element.type !== 'checkbox' && element.type !== 'radio') {
+        throw new Error('Element is not a checkbox or radio');
+      }
+      const wasChecked = element.checked;
+      if (!wasChecked) {
+        element.checked = true;
+        element.dispatchEvent(new Event('change', { bubbles: true }));
+      }
+      return wasChecked;
+    })()
+  `);
+  console.log("[CDPDOMService] Checked element:", { ref, role, name, wasAlreadyChecked: result });
+  return { role, name, wasAlreadyChecked: result };
+}
+async function uncheckElement(tabId, ref) {
+  const refInfo = await getRefInfo(ref);
+  if (!refInfo) {
+    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  }
+  const { xpath, role, name } = refInfo;
+  const result = await evaluate(tabId, `
+    (function() {
+      const result = document.evaluate(
+        ${JSON.stringify(xpath)},
+        document,
+        null,
+        XPathResult.FIRST_ORDERED_NODE_TYPE,
+        null
+      );
+      const element = result.singleNodeValue;
+      if (!element) throw new Error('Element not found');
+      if (element.type !== 'checkbox' && element.type !== 'radio') {
+        throw new Error('Element is not a checkbox or radio');
+      }
+      const wasUnchecked = !element.checked;
+      if (!wasUnchecked) {
+        element.checked = false;
+        element.dispatchEvent(new Event('change', { bubbles: true }));
+      }
+      return wasUnchecked;
+    })()
+  `);
+  console.log("[CDPDOMService] Unchecked element:", { ref, role, name, wasAlreadyUnchecked: result });
+  return { role, name, wasAlreadyUnchecked: result };
+}
+async function selectOption(tabId, ref, value) {
+  const refInfo = await getRefInfo(ref);
+  if (!refInfo) {
+    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  }
+  const { xpath, role, name } = refInfo;
+  const result = await evaluate(tabId, `
+    (function() {
+      const selectValue = ${JSON.stringify(value)};
+      const result = document.evaluate(
+        ${JSON.stringify(xpath)},
+        document,
+        null,
+        XPathResult.FIRST_ORDERED_NODE_TYPE,
+        null
+      );
+      const element = result.singleNodeValue;
+      if (!element) throw new Error('Element not found');
+      if (element.tagName !== 'SELECT') {
+        throw new Error('Element is not a <select> element');
+      }
+      
+      // 尝试通过 value 或 text 匹配
+      let matched = null;
+      for (const opt of element.options) {
+        if (opt.value === selectValue || opt.textContent.trim() === selectValue) {
+          matched = opt;
+          break;
+        }
+      }
+      
+      // 不区分大小写匹配
+      if (!matched) {
+        const lower = selectValue.toLowerCase();
+        for (const opt of element.options) {
+          if (opt.value.toLowerCase() === lower || opt.textContent.trim().toLowerCase() === lower) {
+            matched = opt;
+            break;
+          }
+        }
+      }
+      
+      if (!matched) {
+        const available = Array.from(element.options).map(o => ({ value: o.value, label: o.textContent.trim() }));
+        throw new Error('Option not found: ' + selectValue + '. Available: ' + JSON.stringify(available));
+      }
+      
+      element.value = matched.value;
+      element.dispatchEvent(new Event('change', { bubbles: true }));
+      
+      return { selectedValue: matched.value, selectedLabel: matched.textContent.trim() };
+    })()
+  `);
+  const { selectedValue, selectedLabel } = result;
+  console.log("[CDPDOMService] Selected option:", { ref, role, name, selectedValue });
+  return { role, name, selectedValue, selectedLabel };
+}
+async function waitForElement(tabId, ref, maxWait = 1e4, interval = 200) {
+  const refInfo = await getRefInfo(ref);
+  if (!refInfo) {
+    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  }
+  const { xpath } = refInfo;
+  let elapsed = 0;
+  while (elapsed < maxWait) {
+    const found = await evaluate(tabId, `
+      (function() {
+        const result = document.evaluate(
+          ${JSON.stringify(xpath)},
+          document,
+          null,
+          XPathResult.FIRST_ORDERED_NODE_TYPE,
+          null
+        );
+        return result.singleNodeValue !== null;
+      })()
+    `);
+    if (found) {
+      console.log("[CDPDOMService] Element found:", { ref, elapsed });
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+    elapsed += interval;
+  }
+  throw new Error(`Timeout waiting for element @${ref} after ${maxWait}ms`);
+}
+function setActiveFrameId(frameId) {
+  console.log("[CDPDOMService] Active frame changed:", frameId ?? "main");
+}
+async function pressKey(tabId, key, modifiers = []) {
+  let modifierFlags = 0;
+  if (modifiers.includes("Alt")) modifierFlags |= 1;
+  if (modifiers.includes("Control")) modifierFlags |= 2;
+  if (modifiers.includes("Meta")) modifierFlags |= 4;
+  if (modifiers.includes("Shift")) modifierFlags |= 8;
+  await pressKey$1(tabId, key, { modifiers: modifierFlags });
+  console.log("[CDPDOMService] Pressed key:", key, modifiers);
+}
+async function scrollPage(tabId, direction, pixels) {
+  const result = await evaluate(
+    tabId,
+    "JSON.stringify({ width: window.innerWidth, height: window.innerHeight })"
+  );
+  const { width, height } = JSON.parse(result);
+  const x = width / 2;
+  const y = height / 2;
+  let deltaX = 0;
+  let deltaY = 0;
+  switch (direction) {
+    case "up":
+      deltaY = -pixels;
+      break;
+    case "down":
+      deltaY = pixels;
+      break;
+    case "left":
+      deltaX = -pixels;
+      break;
+    case "right":
+      deltaX = pixels;
+      break;
+  }
+  await scroll(tabId, x, y, deltaX, deltaY);
+  console.log("[CDPDOMService] Scrolled:", { direction, pixels });
+}
+
+let isRecording = false;
+let recordingTabId = null;
+let events = [];
+async function startRecording(tabId) {
+  console.log("[TraceService] Starting recording on tab:", tabId);
+  isRecording = true;
+  recordingTabId = tabId;
+  events = [];
+  try {
+    const tab = await chrome.tabs.get(tabId);
+    if (tab.url) {
+      events.push({
+        type: "navigation",
+        timestamp: Date.now(),
+        url: tab.url,
+        elementRole: "document",
+        elementName: tab.title || "",
+        elementTag: "document"
+      });
+    }
+  } catch (error) {
+    console.error("[TraceService] Error getting tab info:", error);
+  }
+  try {
+    await chrome.tabs.sendMessage(tabId, { type: "TRACE_START" });
+  } catch (error) {
+    console.log("[TraceService] Content script not ready, will record on next event");
+  }
+}
+async function stopRecording() {
+  console.log("[TraceService] Stopping recording, events:", events.length);
+  const recordedEvents = [...events];
+  if (recordingTabId !== null) {
+    try {
+      await chrome.tabs.sendMessage(recordingTabId, { type: "TRACE_STOP" });
+    } catch (error) {
+      console.log("[TraceService] Could not notify content script:", error);
+    }
+  }
+  isRecording = false;
+  recordingTabId = null;
+  events = [];
+  return recordedEvents;
+}
+function getStatus() {
+  return {
+    recording: isRecording,
+    eventCount: events.length,
+    tabId: recordingTabId ?? void 0
+  };
+}
+function addEvent(event) {
+  if (!isRecording) return;
+  console.log("[TraceService] Adding event:", event.type, event);
+  events.push(event);
+}
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  if (message.type === "TRACE_EVENT") {
+    if (isRecording && sender.tab?.id === recordingTabId) {
+      addEvent(message.payload);
+    }
+    sendResponse({ received: true });
+    return true;
+  }
+  if (message.type === "GET_TRACE_STATUS") {
+    sendResponse({
+      recording: isRecording && sender.tab?.id === recordingTabId,
+      tabId: recordingTabId
+    });
+    return true;
+  }
+  return false;
+});
+chrome.tabs.onRemoved.addListener((tabId) => {
+  if (tabId === recordingTabId) {
+    console.log("[TraceService] Recording tab closed, stopping recording");
+    isRecording = false;
+    recordingTabId = null;
+  }
+});
+chrome.tabs.onUpdated.addListener(async (tabId, changeInfo, _tab) => {
+  if (tabId === recordingTabId && isRecording) {
+    if (changeInfo.url) {
+      events.push({
+        type: "navigation",
+        timestamp: Date.now(),
+        url: changeInfo.url,
+        elementRole: "document",
+        elementName: _tab.title || "",
+        elementTag: "document"
+      });
+      console.log("[TraceService] Navigation event:", changeInfo.url);
+    }
+    if (changeInfo.status === "complete") {
+      console.log("[TraceService] Page loaded, notifying content script to start recording");
+      try {
+        await chrome.tabs.sendMessage(tabId, { type: "TRACE_START" });
+      } catch (error) {
+        console.log("[TraceService] Could not notify content script:", error);
+      }
+    }
+  }
+});
+console.log("[TraceService] Initialized");
+
+initEventListeners();
+let activeFrameId = null;
+async function handleCommand(command) {
+  console.log("[CommandHandler] Processing command:", command.id, command.action);
+  let result;
+  try {
+    switch (command.action) {
+      case "open":
+        result = await handleOpen(command);
+        break;
+      case "snapshot":
+        result = await handleSnapshot(command);
+        break;
+      case "click":
+        result = await handleClick(command);
+        break;
+      case "hover":
+        result = await handleHover(command);
+        break;
+      case "fill":
+        result = await handleFill(command);
+        break;
+      case "type":
+        result = await handleType(command);
+        break;
+      case "check":
+        result = await handleCheck(command);
+        break;
+      case "uncheck":
+        result = await handleUncheck(command);
+        break;
+      case "close":
+        result = await handleClose(command);
+        break;
+      case "get":
+        result = await handleGet(command);
+        break;
+      case "screenshot":
+        result = await handleScreenshot(command);
+        break;
+      case "wait":
+        result = await handleWait(command);
+        break;
+      case "press":
+        result = await handlePress(command);
+        break;
+      case "scroll":
+        result = await handleScroll(command);
+        break;
+      case "back":
+        result = await handleBack(command);
+        break;
+      case "forward":
+        result = await handleForward(command);
+        break;
+      case "refresh":
+        result = await handleRefresh(command);
+        break;
+      case "eval":
+        result = await handleEval(command);
+        break;
+      case "select":
+        result = await handleSelect(command);
+        break;
+      case "tab_list":
+        result = await handleTabList(command);
+        break;
+      case "tab_new":
+        result = await handleTabNew(command);
+        break;
+      case "tab_select":
+        result = await handleTabSelect(command);
+        break;
+      case "tab_close":
+        result = await handleTabClose(command);
+        break;
+      case "frame":
+        result = await handleFrame(command);
+        break;
+      case "frame_main":
+        result = await handleFrameMain(command);
+        break;
+      case "dialog":
+        result = await handleDialog(command);
+        break;
+      case "network":
+        result = await handleNetwork(command);
+        break;
+      case "console":
+        result = await handleConsole(command);
+        break;
+      case "errors":
+        result = await handleErrors(command);
+        break;
+      case "trace":
+        result = await handleTrace(command);
+        break;
+      default:
+        result = {
+          id: command.id,
+          success: false,
+          error: `Unknown action: ${command.action}`
+        };
+    }
+  } catch (error) {
+    result = {
+      id: command.id,
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+  await sendResult(result);
+}
+async function handleOpen(command) {
+  const url = command.url;
+  const tabIdParam = command.tabId;
+  if (!url) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing url parameter"
+    };
+  }
+  console.log("[CommandHandler] Opening URL:", url, "tabId:", tabIdParam);
+  let tab;
+  if (tabIdParam === void 0) {
+    tab = await chrome.tabs.create({ url, active: true });
+  } else if (tabIdParam === "current") {
+    const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+    if (activeTab && activeTab.id) {
+      tab = await chrome.tabs.update(activeTab.id, { url });
+    } else {
+      tab = await chrome.tabs.create({ url, active: true });
+    }
+  } else {
+    const targetTabId = typeof tabIdParam === "number" ? tabIdParam : parseInt(String(tabIdParam), 10);
+    if (isNaN(targetTabId)) {
+      return {
+        id: command.id,
+        success: false,
+        error: `Invalid tabId: ${tabIdParam}`
+      };
+    }
+    try {
+      tab = await chrome.tabs.update(targetTabId, { url, active: true });
+    } catch (error) {
+      return {
+        id: command.id,
+        success: false,
+        error: `Tab ${targetTabId} not found or cannot be updated`
+      };
+    }
+  }
+  await waitForTabLoad(tab.id);
+  const updatedTab = await chrome.tabs.get(tab.id);
+  return {
+    id: command.id,
+    success: true,
+    data: {
+      tabId: tab.id,
+      title: updatedTab.title || "",
+      url: updatedTab.url || url
+    }
+  };
+}
+async function handleSnapshot(command) {
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  const url = activeTab.url || "";
+  if (url.startsWith("chrome://") || url.startsWith("about:") || url.startsWith("chrome-extension://")) {
+    return {
+      id: command.id,
+      success: false,
+      error: `Cannot take snapshot of restricted page: ${url}`
+    };
+  }
+  const interactive = command.interactive;
+  console.log("[CommandHandler] Taking snapshot of tab:", activeTab.id, activeTab.url, { interactive });
+  try {
+    const snapshotResult = await getSnapshot(activeTab.id, { interactive });
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        title: activeTab.title || "",
+        url: activeTab.url || "",
+        snapshotData: snapshotResult
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Snapshot failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Snapshot failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleClick(command) {
+  const ref = command.ref;
+  if (!ref) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing ref parameter"
+    };
+  }
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  console.log("[CommandHandler] Clicking element:", ref);
+  try {
+    const elementInfo = await clickElement(activeTab.id, ref);
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        role: elementInfo.role,
+        name: elementInfo.name
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Click failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Click failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleHover(command) {
+  const ref = command.ref;
+  if (!ref) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing ref parameter"
+    };
+  }
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  console.log("[CommandHandler] Hovering element:", ref);
+  try {
+    const elementInfo = await hoverElement(activeTab.id, ref);
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        role: elementInfo.role,
+        name: elementInfo.name
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Hover failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Hover failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleFill(command) {
+  const ref = command.ref;
+  const text = command.text;
+  if (!ref) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing ref parameter"
+    };
+  }
+  if (text === void 0 || text === null) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing text parameter"
+    };
+  }
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  console.log("[CommandHandler] Filling element:", ref, "with text length:", text.length);
+  try {
+    const elementInfo = await fillElement(activeTab.id, ref, text);
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        role: elementInfo.role,
+        name: elementInfo.name,
+        filledText: text
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Fill failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Fill failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleType(command) {
+  const ref = command.ref;
+  const text = command.text;
+  if (!ref) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing ref parameter"
+    };
+  }
+  if (text === void 0 || text === null) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing text parameter"
+    };
+  }
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  console.log("[CommandHandler] Typing in element:", ref, "text length:", text.length);
+  try {
+    const elementInfo = await typeElement(activeTab.id, ref, text);
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        role: elementInfo.role,
+        name: elementInfo.name,
+        typedText: text
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Type failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Type failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleCheck(command) {
+  const ref = command.ref;
+  if (!ref) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing ref parameter"
+    };
+  }
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  console.log("[CommandHandler] Checking element:", ref);
+  try {
+    const elementInfo = await checkElement(activeTab.id, ref);
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        role: elementInfo.role,
+        name: elementInfo.name,
+        wasAlreadyChecked: elementInfo.wasAlreadyChecked
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Check failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Check failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleUncheck(command) {
+  const ref = command.ref;
+  if (!ref) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing ref parameter"
+    };
+  }
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  console.log("[CommandHandler] Unchecking element:", ref);
+  try {
+    const elementInfo = await uncheckElement(activeTab.id, ref);
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        role: elementInfo.role,
+        name: elementInfo.name,
+        wasAlreadyUnchecked: elementInfo.wasAlreadyUnchecked
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Uncheck failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Uncheck failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleSelect(command) {
+  const ref = command.ref;
+  const value = command.value;
+  if (!ref) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing ref parameter"
+    };
+  }
+  if (value === void 0 || value === null) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing value parameter"
+    };
+  }
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  console.log("[CommandHandler] Selecting option:", ref, "value:", value);
+  try {
+    const result = await selectOption(activeTab.id, ref, value);
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        role: result.role,
+        name: result.name,
+        selectedValue: result.selectedValue,
+        selectedLabel: result.selectedLabel
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Select failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Select failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleClose(command) {
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  const tabId = activeTab.id;
+  const title = activeTab.title || "";
+  const url = activeTab.url || "";
+  console.log("[CommandHandler] Closing tab:", tabId, url);
+  try {
+    await chrome.tabs.remove(tabId);
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        tabId,
+        title,
+        url
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Close failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Close failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleGet(command) {
+  const attribute = command.attribute;
+  if (!attribute) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing attribute parameter"
+    };
+  }
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  console.log("[CommandHandler] Getting:", attribute);
+  try {
+    let value;
+    switch (attribute) {
+      case "url":
+        value = activeTab.url || "";
+        break;
+      case "title":
+        value = activeTab.title || "";
+        break;
+      case "text": {
+        const ref = command.ref;
+        if (!ref) {
+          return {
+            id: command.id,
+            success: false,
+            error: "Missing ref parameter for get text"
+          };
+        }
+        value = await getElementText(activeTab.id, ref);
+        break;
+      }
+      default:
+        return {
+          id: command.id,
+          success: false,
+          error: `Unknown attribute: ${attribute}`
+        };
+    }
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        value
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Get failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Get failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleScreenshot(command) {
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id || !activeTab.windowId) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  console.log("[CommandHandler] Taking screenshot of tab:", activeTab.id, activeTab.url);
+  try {
+    const dataUrl = await chrome.tabs.captureVisibleTab(activeTab.windowId, { format: "png" });
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        dataUrl,
+        title: activeTab.title || "",
+        url: activeTab.url || ""
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Screenshot failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Screenshot failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleWait(command) {
+  const waitType = command.waitType;
+  if (waitType === "time") {
+    const ms = command.ms;
+    if (!ms || ms < 0) {
+      return {
+        id: command.id,
+        success: false,
+        error: "Invalid ms parameter"
+      };
+    }
+    console.log("[CommandHandler] Waiting for", ms, "ms");
+    await new Promise((resolve) => setTimeout(resolve, ms));
+    return {
+      id: command.id,
+      success: true,
+      data: { waited: ms }
+    };
+  } else if (waitType === "element") {
+    const ref = command.ref;
+    if (!ref) {
+      return {
+        id: command.id,
+        success: false,
+        error: "Missing ref parameter"
+      };
+    }
+    const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+    if (!activeTab || !activeTab.id) {
+      return {
+        id: command.id,
+        success: false,
+        error: "No active tab found"
+      };
+    }
+    console.log("[CommandHandler] Waiting for element:", ref);
+    try {
+      await waitForElement(activeTab.id, ref);
+      return {
+        id: command.id,
+        success: true,
+        data: { ref }
+      };
+    } catch (error) {
+      console.error("[CommandHandler] Wait failed:", error);
+      return {
+        id: command.id,
+        success: false,
+        error: `Wait failed: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  } else {
+    return {
+      id: command.id,
+      success: false,
+      error: `Unknown wait type: ${waitType}`
+    };
+  }
+}
+async function handlePress(command) {
+  const key = command.key;
+  const modifiers = command.modifiers || [];
+  if (!key) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing key parameter"
+    };
+  }
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  const url = activeTab.url || "";
+  if (url.startsWith("chrome://") || url.startsWith("about:") || url.startsWith("chrome-extension://")) {
+    return {
+      id: command.id,
+      success: false,
+      error: `Cannot send keys to restricted page: ${url}`
+    };
+  }
+  console.log("[CommandHandler] Pressing key:", key, "modifiers:", modifiers);
+  try {
+    await pressKey(activeTab.id, key, modifiers);
+    const displayKey = modifiers.length > 0 ? `${modifiers.join("+")}+${key}` : key;
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        key: displayKey
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Press failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Press failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleScroll(command) {
+  const direction = command.direction;
+  const pixels = command.pixels || 300;
+  if (!direction) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing direction parameter"
+    };
+  }
+  if (!["up", "down", "left", "right"].includes(direction)) {
+    return {
+      id: command.id,
+      success: false,
+      error: `Invalid direction: ${direction}`
+    };
+  }
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  console.log("[CommandHandler] Scrolling:", direction, pixels, "px");
+  try {
+    await scrollPage(activeTab.id, direction, pixels);
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        direction,
+        pixels
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Scroll failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Scroll failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleBack(command) {
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  const tabId = activeTab.id;
+  console.log("[CommandHandler] Going back in tab:", tabId);
+  try {
+    const canGoBack = await evaluate(tabId, "window.history.length > 1");
+    if (!canGoBack) {
+      return {
+        id: command.id,
+        success: false,
+        error: "No previous page in history"
+      };
+    }
+    await evaluate(tabId, "window.history.back()");
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+    const updatedTab = await chrome.tabs.get(tabId);
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        url: updatedTab.url || "",
+        title: updatedTab.title || ""
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Back failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Back failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleForward(command) {
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  const tabId = activeTab.id;
+  console.log("[CommandHandler] Going forward in tab:", tabId);
+  try {
+    await evaluate(tabId, "window.history.forward()");
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+    const updatedTab = await chrome.tabs.get(tabId);
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        url: updatedTab.url || "",
+        title: updatedTab.title || ""
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Forward failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Forward failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleRefresh(command) {
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  console.log("[CommandHandler] Refreshing tab:", activeTab.id);
+  try {
+    await chrome.tabs.reload(activeTab.id);
+    await waitForTabLoad(activeTab.id);
+    const updatedTab = await chrome.tabs.get(activeTab.id);
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        url: updatedTab.url || "",
+        title: updatedTab.title || ""
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Refresh failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Refresh failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleEval(command) {
+  const script = command.script;
+  if (!script) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing script parameter"
+    };
+  }
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  const url = activeTab.url || "";
+  if (url.startsWith("chrome://") || url.startsWith("about:") || url.startsWith("chrome-extension://")) {
+    return {
+      id: command.id,
+      success: false,
+      error: `Cannot execute script on restricted page: ${url}`
+    };
+  }
+  console.log("[CommandHandler] Evaluating script:", script.substring(0, 100));
+  const tabId = activeTab.id;
+  try {
+    const result = await evaluate(tabId, script);
+    console.log("[CommandHandler] Eval result:", JSON.stringify(result));
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        result
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Eval failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Eval failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleTabList(command) {
+  console.log("[CommandHandler] Listing all tabs");
+  try {
+    const tabs = await chrome.tabs.query({ currentWindow: true });
+    const tabInfos = tabs.map((tab) => ({
+      index: tab.index,
+      url: tab.url || "",
+      title: tab.title || "",
+      active: tab.active || false,
+      tabId: tab.id || 0
+    }));
+    const activeTab = tabInfos.find((t) => t.active);
+    const activeIndex = activeTab?.index ?? 0;
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        tabs: tabInfos,
+        activeIndex
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Tab list failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Tab list failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleTabNew(command) {
+  const url = command.url;
+  console.log("[CommandHandler] Creating new tab:", url || "about:blank");
+  try {
+    const createOptions = { active: true };
+    if (url) {
+      createOptions.url = url;
+    }
+    const tab = await chrome.tabs.create(createOptions);
+    if (url && tab.id) {
+      await waitForTabLoad(tab.id);
+    }
+    const updatedTab = tab.id ? await chrome.tabs.get(tab.id) : tab;
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        tabId: updatedTab.id,
+        title: updatedTab.title || "",
+        url: updatedTab.url || ""
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Tab new failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Tab new failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleTabSelect(command) {
+  const index = command.index;
+  if (index === void 0 || index < 0) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing or invalid index parameter"
+    };
+  }
+  console.log("[CommandHandler] Selecting tab at index:", index);
+  try {
+    const tabs = await chrome.tabs.query({ currentWindow: true });
+    const targetTab = tabs.find((t) => t.index === index);
+    if (!targetTab || !targetTab.id) {
+      return {
+        id: command.id,
+        success: false,
+        error: `No tab found at index ${index} (total tabs: ${tabs.length})`
+      };
+    }
+    await chrome.tabs.update(targetTab.id, { active: true });
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        tabId: targetTab.id,
+        title: targetTab.title || "",
+        url: targetTab.url || ""
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Tab select failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Tab select failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleTabClose(command) {
+  const index = command.index;
+  console.log("[CommandHandler] Closing tab at index:", index ?? "current");
+  try {
+    let targetTab;
+    if (index !== void 0) {
+      const tabs = await chrome.tabs.query({ currentWindow: true });
+      const found = tabs.find((t) => t.index === index);
+      if (!found || !found.id) {
+        return {
+          id: command.id,
+          success: false,
+          error: `No tab found at index ${index} (total tabs: ${tabs.length})`
+        };
+      }
+      targetTab = found;
+    } else {
+      const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+      if (!activeTab || !activeTab.id) {
+        return {
+          id: command.id,
+          success: false,
+          error: "No active tab found"
+        };
+      }
+      targetTab = activeTab;
+    }
+    const tabId = targetTab.id;
+    const title = targetTab.title || "";
+    const url = targetTab.url || "";
+    await chrome.tabs.remove(tabId);
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        tabId,
+        title,
+        url
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Tab close failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Tab close failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleFrame(command) {
+  const selector = command.selector;
+  if (!selector) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing selector parameter"
+    };
+  }
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  const tabId = activeTab.id;
+  console.log("[CommandHandler] Switching to frame:", selector);
+  try {
+    const iframeInfoResults = await chrome.scripting.executeScript({
+      target: { tabId, frameIds: activeFrameId !== null ? [activeFrameId] : [0] },
+      func: (sel) => {
+        const iframe = document.querySelector(sel);
+        if (!iframe) {
+          return { found: false, error: `找不到 iframe: ${sel}` };
+        }
+        if (iframe.tagName.toLowerCase() !== "iframe" && iframe.tagName.toLowerCase() !== "frame") {
+          return { found: false, error: `元素不是 iframe: ${iframe.tagName}` };
+        }
+        return {
+          found: true,
+          name: iframe.name || "",
+          src: iframe.src || "",
+          // 获取 iframe 在页面中的位置用于匹配
+          rect: iframe.getBoundingClientRect()
+        };
+      },
+      args: [selector]
+    });
+    const iframeInfo = iframeInfoResults[0]?.result;
+    if (!iframeInfo || !iframeInfo.found) {
+      return {
+        id: command.id,
+        success: false,
+        error: iframeInfo?.error || `找不到 iframe: ${selector}`
+      };
+    }
+    const frames = await chrome.webNavigation.getAllFrames({ tabId });
+    if (!frames || frames.length === 0) {
+      return {
+        id: command.id,
+        success: false,
+        error: "无法获取页面 frames"
+      };
+    }
+    let targetFrameId = null;
+    if (iframeInfo.src) {
+      const matchedFrame = frames.find(
+        (f) => f.url === iframeInfo.src || f.url.includes(iframeInfo.src) || iframeInfo.src.includes(f.url)
+      );
+      if (matchedFrame) {
+        targetFrameId = matchedFrame.frameId;
+      }
+    }
+    if (targetFrameId === null) {
+      const childFrames = frames.filter((f) => f.frameId !== 0);
+      if (childFrames.length === 1) {
+        targetFrameId = childFrames[0].frameId;
+      } else if (childFrames.length > 1) {
+        if (iframeInfo.name) {
+          console.log("[CommandHandler] Multiple frames found, using URL matching");
+        }
+        if (targetFrameId === null) {
+          return {
+            id: command.id,
+            success: false,
+            error: `找到多个子 frame，无法确定目标。请使用更精确的 selector 或确保 iframe 有 src 属性。`
+          };
+        }
+      } else {
+        return {
+          id: command.id,
+          success: false,
+          error: "页面中没有子 frame"
+        };
+      }
+    }
+    try {
+      await chrome.scripting.executeScript({
+        target: { tabId, frameIds: [targetFrameId] },
+        func: () => true
+      });
+    } catch (e) {
+      return {
+        id: command.id,
+        success: false,
+        error: `无法访问 frame (frameId: ${targetFrameId})，可能是跨域 iframe`
+      };
+    }
+    activeFrameId = targetFrameId;
+    setActiveFrameId(String(targetFrameId));
+    const matchedFrameInfo = frames.find((f) => f.frameId === targetFrameId);
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        frameInfo: {
+          selector,
+          name: iframeInfo.name,
+          url: matchedFrameInfo?.url || iframeInfo.src,
+          frameId: targetFrameId
+        }
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Frame switch failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Frame switch failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleFrameMain(command) {
+  console.log("[CommandHandler] Switching to main frame");
+  activeFrameId = null;
+  setActiveFrameId(null);
+  return {
+    id: command.id,
+    success: true,
+    data: {
+      frameInfo: {
+        frameId: 0
+      }
+    }
+  };
+}
+async function handleDialog(command) {
+  const dialogResponse = command.dialogResponse;
+  const promptText = command.promptText;
+  if (!dialogResponse || !["accept", "dismiss"].includes(dialogResponse)) {
+    return {
+      id: command.id,
+      success: false,
+      error: "Missing or invalid dialogResponse parameter (accept/dismiss)"
+    };
+  }
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  const tabId = activeTab.id;
+  console.log("[CommandHandler] Handling dialog:", dialogResponse, "promptText:", promptText);
+  try {
+    const pendingDialog = getPendingDialog(tabId);
+    if (!pendingDialog) {
+      return {
+        id: command.id,
+        success: false,
+        error: "没有待处理的对话框"
+      };
+    }
+    await handleJavaScriptDialog(
+      tabId,
+      dialogResponse === "accept",
+      dialogResponse === "accept" ? promptText : void 0
+    );
+    const dialogInfo = {
+      type: pendingDialog.type,
+      message: pendingDialog.message,
+      handled: true
+    };
+    return {
+      id: command.id,
+      success: true,
+      data: {
+        dialogInfo
+      }
+    };
+  } catch (error) {
+    console.error("[CommandHandler] Dialog handling failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Dialog failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function waitForTabLoad(tabId, timeout = 3e4) {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      chrome.tabs.onUpdated.removeListener(listener);
+      reject(new Error("Tab load timeout"));
+    }, timeout);
+    const listener = (updatedTabId, changeInfo) => {
+      if (updatedTabId === tabId && changeInfo.status === "complete") {
+        clearTimeout(timeoutId);
+        chrome.tabs.onUpdated.removeListener(listener);
+        resolve();
+      }
+    };
+    chrome.tabs.onUpdated.addListener(listener);
+  });
+}
+async function handleNetwork(command) {
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  const tabId = activeTab.id;
+  const subCommand = command.networkCommand;
+  const urlPattern = command.url;
+  console.log("[CommandHandler] Network command:", subCommand, urlPattern);
+  try {
+    switch (subCommand) {
+      case "requests": {
+        await enableNetwork(tabId);
+        const filter = command.filter;
+        const requests = getNetworkRequests(tabId, filter);
+        const networkRequests = requests.map((r) => ({
+          requestId: r.requestId,
+          url: r.url,
+          method: r.method,
+          type: r.type,
+          timestamp: r.timestamp,
+          status: r.response?.status,
+          statusText: r.response?.statusText,
+          failed: r.failed,
+          failureReason: r.failureReason
+        }));
+        return {
+          id: command.id,
+          success: true,
+          data: {
+            networkRequests
+          }
+        };
+      }
+      case "route": {
+        if (!urlPattern) {
+          return {
+            id: command.id,
+            success: false,
+            error: "URL pattern required for route command"
+          };
+        }
+        const options = command.routeOptions || {};
+        await addNetworkRoute(tabId, urlPattern, options);
+        const routeCount = getNetworkRoutes(tabId).length;
+        return {
+          id: command.id,
+          success: true,
+          data: {
+            routeCount
+          }
+        };
+      }
+      case "unroute": {
+        removeNetworkRoute(tabId, urlPattern);
+        const routeCount = getNetworkRoutes(tabId).length;
+        return {
+          id: command.id,
+          success: true,
+          data: {
+            routeCount
+          }
+        };
+      }
+      case "clear": {
+        clearNetworkRequests(tabId);
+        return {
+          id: command.id,
+          success: true,
+          data: {}
+        };
+      }
+      default:
+        return {
+          id: command.id,
+          success: false,
+          error: `Unknown network subcommand: ${subCommand}`
+        };
+    }
+  } catch (error) {
+    console.error("[CommandHandler] Network command failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Network command failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleConsole(command) {
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  const tabId = activeTab.id;
+  const subCommand = command.consoleCommand || "get";
+  console.log("[CommandHandler] Console command:", subCommand);
+  try {
+    await enableConsole(tabId);
+    switch (subCommand) {
+      case "get": {
+        const messages = getConsoleMessages(tabId);
+        return {
+          id: command.id,
+          success: true,
+          data: {
+            consoleMessages: messages
+          }
+        };
+      }
+      case "clear": {
+        clearConsoleMessages(tabId);
+        return {
+          id: command.id,
+          success: true,
+          data: {}
+        };
+      }
+      default:
+        return {
+          id: command.id,
+          success: false,
+          error: `Unknown console subcommand: ${subCommand}`
+        };
+    }
+  } catch (error) {
+    console.error("[CommandHandler] Console command failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Console command failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleErrors(command) {
+  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!activeTab || !activeTab.id) {
+    return {
+      id: command.id,
+      success: false,
+      error: "No active tab found"
+    };
+  }
+  const tabId = activeTab.id;
+  const subCommand = command.errorsCommand || "get";
+  console.log("[CommandHandler] Errors command:", subCommand);
+  try {
+    await enableConsole(tabId);
+    switch (subCommand) {
+      case "get": {
+        const errors = getJSErrors(tabId);
+        return {
+          id: command.id,
+          success: true,
+          data: {
+            jsErrors: errors
+          }
+        };
+      }
+      case "clear": {
+        clearJSErrors(tabId);
+        return {
+          id: command.id,
+          success: true,
+          data: {}
+        };
+      }
+      default:
+        return {
+          id: command.id,
+          success: false,
+          error: `Unknown errors subcommand: ${subCommand}`
+        };
+    }
+  } catch (error) {
+    console.error("[CommandHandler] Errors command failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Errors command failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function handleTrace(command) {
+  const subCommand = command.traceCommand || "status";
+  console.log("[CommandHandler] Trace command:", subCommand);
+  try {
+    switch (subCommand) {
+      case "start": {
+        const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+        if (!activeTab || !activeTab.id) {
+          return {
+            id: command.id,
+            success: false,
+            error: "No active tab found"
+          };
+        }
+        const url = activeTab.url || "";
+        if (url.startsWith("chrome://") || url.startsWith("about:") || url.startsWith("chrome-extension://")) {
+          return {
+            id: command.id,
+            success: false,
+            error: `Cannot record on restricted page: ${url}`
+          };
+        }
+        await startRecording(activeTab.id);
+        const status = getStatus();
+        return {
+          id: command.id,
+          success: true,
+          data: {
+            traceStatus: status
+          }
+        };
+      }
+      case "stop": {
+        const events = await stopRecording();
+        return {
+          id: command.id,
+          success: true,
+          data: {
+            traceEvents: events,
+            traceStatus: {
+              recording: false,
+              eventCount: events.length
+            }
+          }
+        };
+      }
+      case "status": {
+        const status = getStatus();
+        return {
+          id: command.id,
+          success: true,
+          data: {
+            traceStatus: status
+          }
+        };
+      }
+      default:
+        return {
+          id: command.id,
+          success: false,
+          error: `Unknown trace subcommand: ${subCommand}`
+        };
+    }
+  } catch (error) {
+    console.error("[CommandHandler] Trace command failed:", error);
+    return {
+      id: command.id,
+      success: false,
+      error: `Trace command failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
+const KEEPALIVE_ALARM = "bb-browser-keepalive";
+const sseClient = new SSEClient();
+sseClient.onCommand(handleCommand);
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  console.log("[bb-browser] Message from content script:", message, "sender:", sender.tab?.id);
+  sendResponse({ received: true });
+  return true;
+});
+async function setupKeepaliveAlarm() {
+  await chrome.alarms.clear(KEEPALIVE_ALARM);
+  await chrome.alarms.create(KEEPALIVE_ALARM, {
+    periodInMinutes: 0.4
+    // 24 秒
+  });
+  console.log("[bb-browser] Keepalive alarm set (every 24s)");
+}
+chrome.alarms.onAlarm.addListener((alarm) => {
+  if (alarm.name === KEEPALIVE_ALARM) {
+    console.log("[bb-browser] Keepalive alarm triggered, checking connection...");
+    if (!sseClient.isConnected()) {
+      console.log("[bb-browser] SSE disconnected, reconnecting...");
+      sseClient.connect();
+    }
+  }
+});
+chrome.runtime.onInstalled.addListener((details) => {
+  console.log("[bb-browser] Extension installed/updated:", details.reason);
+  sseClient.connect();
+  setupKeepaliveAlarm();
+});
+chrome.runtime.onStartup.addListener(() => {
+  console.log("[bb-browser] Browser started, connecting to daemon...");
+  sseClient.connect();
+  setupKeepaliveAlarm();
+});
+console.log("[bb-browser] Background service worker started, connecting to daemon...");
+sseClient.connect();
+setupKeepaliveAlarm();
+//# sourceMappingURL=background.js.map