bb-browser 0.2.2 → 0.4.0

package/extension/dist/background.js

@@ -216,7 +216,11 @@ const consoleMessages = /* @__PURE__ */ new Map();
 const jsErrors = /* @__PURE__ */ new Map();
 const networkRoutes = /* @__PURE__ */ new Map();
 const networkEnabledTabs = /* @__PURE__ */ new Set();
+const networkBodyBytes = /* @__PURE__ */ new Map();
 const MAX_REQUESTS = 500;
+const MAX_REQUEST_BODY_BYTES = 64 * 1024;
+const MAX_RESPONSE_BODY_BYTES = 256 * 1024;
+const MAX_TAB_BODY_BYTES = 8 * 1024 * 1024;
 const MAX_CONSOLE_MESSAGES = 500;
 const MAX_ERRORS = 100;
 async function ensureAttached(tabId) {
@@ -256,6 +260,41 @@ async function evaluate(tabId, expression, options = {}) {
   }
   return result.result?.value;
 }
+async function callFunctionOn(tabId, objectId, functionDeclaration, args = []) {
+  const result = await sendCommand(tabId, "Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration,
+    arguments: args.map((arg) => ({ value: arg })),
+    returnByValue: true,
+    awaitPromise: true
+  });
+  if (result.exceptionDetails) {
+    throw new Error(result.exceptionDetails.exception?.description || "Call failed");
+  }
+  return result.result?.value;
+}
+async function getDocument(tabId, options = {}) {
+  const result = await sendCommand(tabId, "DOM.getDocument", {
+    depth: options.depth ?? -1,
+    // -1 表示获取整个树
+    pierce: options.pierce ?? true
+    // 穿透 shadow DOM 和 iframe
+  });
+  return result.root;
+}
+async function querySelector(tabId, nodeId, selector) {
+  const result = await sendCommand(tabId, "DOM.querySelector", {
+    nodeId,
+    selector
+  });
+  return result.nodeId;
+}
+async function resolveNodeByBackendId(tabId, backendNodeId) {
+  const result = await sendCommand(tabId, "DOM.resolveNode", {
+    backendNodeId
+  });
+  return result.object.objectId;
+}
 async function dispatchMouseEvent(tabId, type, x, y, options = {}) {
   await sendCommand(tabId, "Input.dispatchMouseEvent", {
     type,
@@ -335,6 +374,32 @@ async function handleJavaScriptDialog(tabId, accept, promptText) {
 function getPendingDialog(tabId) {
   return pendingDialogs.get(tabId);
 }
+async function getFullAccessibilityTree(tabId, options = {}) {
+  await sendCommand(tabId, "Accessibility.enable");
+  const result = await sendCommand(
+    tabId,
+    "Accessibility.getFullAXTree",
+    {
+      depth: options.depth,
+      frameId: options.frameId
+    }
+  );
+  return result.nodes;
+}
+async function getPartialAccessibilityTree(tabId, nodeId, backendNodeId, options = {}) {
+  await sendCommand(tabId, "Accessibility.enable");
+  const result = await sendCommand(
+    tabId,
+    "Accessibility.getPartialAXTree",
+    {
+      nodeId,
+      backendNodeId,
+      fetchRelatives: options.fetchRelatives ?? true,
+      depth: options.depth
+    }
+  );
+  return result.nodes;
+}
 async function enableNetwork(tabId) {
   if (networkEnabledTabs.has(tabId)) return;
   await ensureAttached(tabId);
@@ -346,18 +411,34 @@ async function enableNetwork(tabId) {
   if (!networkRequests.has(tabId)) {
     networkRequests.set(tabId, []);
   }
+  if (!networkBodyBytes.has(tabId)) {
+    networkBodyBytes.set(tabId, 0);
+  }
   console.log("[CDPService] Network enabled for tab:", tabId);
 }
-function getNetworkRequests(tabId, filter) {
+function getNetworkRequests(tabId, filter, withBody = false) {
   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)
+  const filtered = !filter ? requests : requests.filter(
+    (r) => r.url.toLowerCase().includes(filter.toLowerCase()) || r.method.toLowerCase().includes(filter.toLowerCase()) || r.type.toLowerCase().includes(filter.toLowerCase())
   );
+  if (withBody) return filtered;
+  return filtered.map((r) => ({
+    requestId: r.requestId,
+    url: r.url,
+    method: r.method,
+    type: r.type,
+    timestamp: r.timestamp,
+    response: r.response ? {
+      status: r.response.status,
+      statusText: r.response.statusText
+    } : void 0,
+    failed: r.failed,
+    failureReason: r.failureReason
+  }));
 }
 function clearNetworkRequests(tabId) {
   networkRequests.set(tabId, []);
+  networkBodyBytes.set(tabId, 0);
 }
 async function addNetworkRoute(tabId, urlPattern, options = {}) {
   await enableNetwork(tabId);
@@ -428,6 +509,8 @@ function initEventListeners() {
       handleNetworkResponse(tabId, params);
     } else if (method === "Network.loadingFailed") {
       handleNetworkFailed(tabId, params);
+    } else if (method === "Network.loadingFinished") {
+      void handleNetworkLoadingFinished(tabId, params);
     } else if (method === "Fetch.requestPaused") {
       handleFetchPaused(tabId, params);
     } else if (method === "Runtime.consoleAPICalled") {
@@ -454,24 +537,69 @@ function cleanupTab$2(tabId) {
   networkRequests.delete(tabId);
   networkRoutes.delete(tabId);
   networkEnabledTabs.delete(tabId);
+  networkBodyBytes.delete(tabId);
   consoleMessages.delete(tabId);
   jsErrors.delete(tabId);
 }
+function estimateBodyBytes(value) {
+  return value ? value.length * 2 : 0;
+}
+function truncateBody(value, maxBytes) {
+  const maxChars = Math.max(0, Math.floor(maxBytes / 2));
+  if (value.length <= maxChars) {
+    return { body: value, truncated: false };
+  }
+  return { body: value.slice(0, maxChars), truncated: true };
+}
+function getStoredBodyBytes(request) {
+  return estimateBodyBytes(request.requestBody) + estimateBodyBytes(request.response?.body);
+}
+function updateTabBodyBytes(tabId) {
+  const requests = networkRequests.get(tabId) || [];
+  let total = 0;
+  for (const request of requests) {
+    total += getStoredBodyBytes(request);
+  }
+  networkBodyBytes.set(tabId, total);
+}
+function enforceBodyBudget(tabId) {
+  const requests = networkRequests.get(tabId) || [];
+  let total = networkBodyBytes.get(tabId) || 0;
+  for (const request of requests) {
+    if (total <= MAX_TAB_BODY_BYTES) break;
+    if (request.requestBody) {
+      total -= estimateBodyBytes(request.requestBody);
+      delete request.requestBody;
+      request.requestBodyTruncated = true;
+    }
+    if (total <= MAX_TAB_BODY_BYTES) break;
+    if (request.response?.body) {
+      total -= estimateBodyBytes(request.response.body);
+      delete request.response.body;
+      request.response.bodyTruncated = true;
+    }
+  }
+  networkBodyBytes.set(tabId, Math.max(0, total));
+}
 function handleNetworkRequest(tabId, params) {
   const requests = networkRequests.get(tabId) || [];
   if (requests.length >= MAX_REQUESTS) {
     requests.shift();
   }
+  const truncatedRequestBody = params.request.postData ? truncateBody(params.request.postData, MAX_REQUEST_BODY_BYTES) : void 0;
   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
+    requestHeaders: params.request.headers,
+    requestBody: truncatedRequestBody?.body,
+    requestBodyTruncated: truncatedRequestBody?.truncated
   });
   networkRequests.set(tabId, requests);
+  updateTabBodyBytes(tabId);
+  enforceBodyBudget(tabId);
 }
 function handleNetworkResponse(tabId, params) {
   const requests = networkRequests.get(tabId) || [];
@@ -481,10 +609,38 @@ function handleNetworkResponse(tabId, params) {
       status: params.response.status,
       statusText: params.response.statusText,
       headers: params.response.headers,
-      mimeType: params.response.mimeType
+      mimeType: params.response.mimeType,
+      body: request.response?.body,
+      bodyBase64: request.response?.bodyBase64,
+      bodyTruncated: request.response?.bodyTruncated
     };
   }
 }
+async function handleNetworkLoadingFinished(tabId, params) {
+  const requests = networkRequests.get(tabId) || [];
+  const request = requests.find((r) => r.requestId === params.requestId);
+  if (!request || request.failed) {
+    return;
+  }
+  try {
+    const result = await sendCommand(tabId, "Network.getResponseBody", { requestId: params.requestId });
+    const truncatedResponseBody = truncateBody(result.body, MAX_RESPONSE_BODY_BYTES);
+    request.response = {
+      status: request.response?.status ?? 0,
+      statusText: request.response?.statusText ?? "",
+      headers: request.response?.headers,
+      mimeType: request.response?.mimeType,
+      body: truncatedResponseBody.body,
+      bodyBase64: result.base64Encoded,
+      bodyTruncated: truncatedResponseBody.truncated
+    };
+    request.bodyError = void 0;
+    updateTabBodyBytes(tabId);
+    enforceBodyBudget(tabId);
+  } catch (error) {
+    request.bodyError = error instanceof Error ? error.message : String(error);
+  }
+}
 function handleNetworkFailed(tabId, params) {
   const requests = networkRequests.get(tabId) || [];
   const request = requests.find((r) => r.requestId === params.requestId);
@@ -600,326 +756,264 @@ function handleException(tabId, params) {
   jsErrors.set(tabId, errors);
 }
 
-const tabSnapshotRefs$1 = /* @__PURE__ */ new Map();
-const tabActiveFrameId$2 = /* @__PURE__ */ new Map();
-function cleanupTab$1(tabId) {
-  tabSnapshotRefs$1.delete(tabId);
-  tabActiveFrameId$2.delete(tabId);
-}
-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);
-  tabSnapshotRefs$1.set(tabId, 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) {
-  const frameId = tabActiveFrameId$2.get(tabId) ?? null;
-  if (frameId !== null) {
-    return { tabId, frameIds: [frameId] };
-  }
-  return { tabId };
+const INTERACTIVE_ROLES = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "textbox",
+  "searchbox",
+  "combobox",
+  "listbox",
+  "checkbox",
+  "radio",
+  "slider",
+  "spinbutton",
+  "switch",
+  "tab",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "option",
+  "treeitem"
+]);
+const SKIP_ROLES = /* @__PURE__ */ new Set([
+  "none",
+  "InlineTextBox",
+  "LineBreak",
+  "Ignored"
+]);
+const CONTENT_ROLES_WITH_REF = /* @__PURE__ */ new Set([
+  "heading",
+  "img",
+  "cell",
+  "columnheader",
+  "rowheader"
+]);
+function createRoleNameTracker() {
+  const counts = /* @__PURE__ */ new Map();
+  const refsByKey = /* @__PURE__ */ new Map();
+  return {
+    counts,
+    refsByKey,
+    getKey(role, name) {
+      return `${role}:${name ?? ""}`;
+    },
+    getNextIndex(role, name) {
+      const key = this.getKey(role, name);
+      const current = counts.get(key) ?? 0;
+      counts.set(key, current + 1);
+      return current;
+    },
+    trackRef(role, name, ref) {
+      const key = this.getKey(role, name);
+      const refs = refsByKey.get(key) ?? [];
+      refs.push(ref);
+      refsByKey.set(key, refs);
+    },
+    getDuplicateKeys() {
+      const duplicates = /* @__PURE__ */ new Set();
+      for (const [key, refs] of refsByKey) {
+        if (refs.length > 1) duplicates.add(key);
+      }
+      return duplicates;
+    }
+  };
 }
-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;
+function removeNthFromNonDuplicates(refs, tracker) {
+  const duplicateKeys = tracker.getDuplicateKeys();
+  for (const refInfo of Object.values(refs)) {
+    const key = tracker.getKey(refInfo.role, refInfo.name);
+    if (!duplicateKeys.has(key)) {
+      delete refInfo.nth;
     }
-    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 getProperty(node, propName) {
+  const prop = node.properties?.find((p) => p.name === propName);
+  return prop?.value?.value;
 }
-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 truncate(text, max = 80) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 3) + "...";
 }
-function truncateText(text, maxLength = 50) {
-  if (text.length <= maxLength) return text;
-  return text.slice(0, maxLength - 3) + "...";
+function indent(depth) {
+  return "  ".repeat(depth);
 }
-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 getIndentLevel(line) {
+  const match = line.match(/^(\s*)/);
+  return match ? Math.floor(match[1].length / 2) : 0;
 }
-function convertToAccessibilityTree(result) {
+function formatAXTree(nodes, urlMap, options = {}) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    nodeMap.set(node.nodeId, node);
+  }
+  const rootNode = nodes[0];
+  if (!rootNode) {
+    return { snapshot: "(empty)", refs: {} };
+  }
   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 tracker = createRoleNameTracker();
+  let refCounter = 0;
+  function nextRef() {
+    return String(refCounter++);
+  }
+  function shouldAssignRef(role) {
+    if (options.interactive) {
+      return INTERACTIVE_ROLES.has(role);
+    }
+    return INTERACTIVE_ROLES.has(role) || CONTENT_ROLES_WITH_REF.has(role);
   }
-  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;
+  function traverse(nodeId, depth) {
+    const node = nodeMap.get(nodeId);
+    if (!node) return;
+    if (node.ignored) {
+      for (const childId of node.childIds || []) {
+        traverse(childId, depth);
       }
+      return;
     }
-    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 (options.maxDepth !== void 0 && depth > options.maxDepth) return;
+    const role = node.role?.value || "";
+    if (SKIP_ROLES.has(role)) {
+      for (const childId of node.childIds || []) {
+        traverse(childId, depth);
       }
+      return;
     }
-    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}`);
+    const name = node.name?.value?.trim() || "";
+    const isInteractive = INTERACTIVE_ROLES.has(role);
+    if (options.interactive && !isInteractive) {
+      for (const childId of node.childIds || []) {
+        traverse(childId, depth);
+      }
       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 (role === "StaticText") {
+      if (name) {
+        const displayText = truncate(name, 100);
+        lines.push(`${indent(depth)}- text: ${displayText}`);
+      }
+      return;
+    }
+    if ((role === "GenericContainer" || role === "generic") && !name) {
+      for (const childId of node.childIds || []) {
+        traverse(childId, depth);
+      }
+      return;
+    }
+    const displayRole = role.charAt(0).toLowerCase() + role.slice(1);
+    let line = `${indent(depth)}- ${displayRole}`;
     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
+      line += ` "${truncate(name, 50)}"`;
+    }
+    const level = getProperty(node, "level");
+    if (level !== void 0) {
+      line += ` [level=${level}]`;
+    }
+    const hasBackendId = node.backendDOMNodeId !== void 0;
+    if (shouldAssignRef(role) && hasBackendId) {
+      const ref = nextRef();
+      const nth = tracker.getNextIndex(role, name || void 0);
+      tracker.trackRef(role, name || void 0, ref);
+      line += ` [ref=${ref}]`;
+      if (nth > 0) line += ` [nth=${nth}]`;
+      refs[ref] = {
+        backendDOMNodeId: node.backendDOMNodeId,
+        role: displayRole,
+        name: name || void 0,
+        nth
       };
     }
+    if (!options.interactive && role === "link" && node.backendDOMNodeId !== void 0) {
+      const url = urlMap.get(node.backendDOMNodeId);
+      if (url) {
+        lines.push(line);
+        lines.push(`${indent(depth + 1)}- /url: ${url}`);
+        for (const childId of node.childIds || []) {
+          traverse(childId, depth + 1);
+        }
+        return;
+      }
+    }
     lines.push(line);
-    for (const childId of elementNode.children || []) {
+    if (options.interactive) return;
+    for (const childId of node.childIds || []) {
       traverse(childId, depth + 1);
     }
   }
-  const rootNode = map[rootId];
-  if (rootNode && !("type" in rootNode)) {
-    for (const childId of rootNode.children || []) {
-      traverse(childId, 0);
+  traverse(rootNode.nodeId, 0);
+  removeNthFromNonDuplicates(refs, tracker);
+  const duplicateKeys = tracker.getDuplicateKeys();
+  const cleanedLines = lines.map((line) => {
+    const nthMatch = line.match(/\[nth=0\]/);
+    if (nthMatch) {
+      return line.replace(" [nth=0]", "");
+    }
+    const refMatch = line.match(/\[ref=(\d+)\].*\[nth=\d+\]/);
+    if (refMatch) {
+      const refId = refMatch[1];
+      const refInfo = refs[refId];
+      if (refInfo) {
+        const key = tracker.getKey(refInfo.role, refInfo.name);
+        if (!duplicateKeys.has(key)) {
+          return line.replace(/\s*\[nth=\d+\]/, "");
+        }
+      }
+    }
+    return line;
+  });
+  let snapshot = cleanedLines.join("\n");
+  if (options.compact) {
+    snapshot = compactTree(snapshot);
+  }
+  return { snapshot: snapshot || "(empty)", refs };
+}
+function compactTree(tree) {
+  const lines = tree.split("\n");
+  const result = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.includes("[ref=")) {
+      result.push(line);
+      continue;
+    }
+    if (line.includes("- text:") || line.includes("- /url:")) {
+      result.push(line);
+      continue;
+    }
+    if (line.includes('"')) {
+      result.push(line);
+      continue;
+    }
+    const currentIndent = getIndentLevel(line);
+    let hasRelevantChildren = false;
+    for (let j = i + 1; j < lines.length; j++) {
+      const childIndent = getIndentLevel(lines[j]);
+      if (childIndent <= currentIndent) break;
+      if (lines[j].includes("[ref=") || lines[j].includes('"') || lines[j].includes("- text:")) {
+        hasRelevantChildren = true;
+        break;
+      }
+    }
+    if (hasRelevantChildren) {
+      result.push(line);
     }
   }
-  return { snapshot: lines.join("\n"), refs };
+  return result.join("\n");
 }
 
-const tabSnapshotRefs = /* @__PURE__ */ new Map();
-const tabActiveFrameId$1 = /* @__PURE__ */ new Map();
+const tabSnapshotRefs$1 = /* @__PURE__ */ new Map();
+const tabActiveFrameId$2 = /* @__PURE__ */ new Map();
 async function loadRefsFromStorage() {
   try {
     const result = await chrome.storage.session.get("tabSnapshotRefs");
     if (result.tabSnapshotRefs) {
       const stored = result.tabSnapshotRefs;
       for (const [tabIdStr, refs] of Object.entries(stored)) {
-        tabSnapshotRefs.set(Number(tabIdStr), refs);
+        tabSnapshotRefs$1.set(Number(tabIdStr), refs);
       }
-      console.log("[CDPDOMService] Loaded refs from storage:", tabSnapshotRefs.size, "tabs");
+      console.log("[CDPDOMService] Loaded refs from storage:", tabSnapshotRefs$1.size, "tabs");
     }
   } catch (e) {
     console.warn("[CDPDOMService] Failed to load refs from storage:", e);
@@ -931,159 +1025,221 @@ async function saveRefsToStorage(tabId, refs) {
     const stored = result.tabSnapshotRefs || {};
     stored[String(tabId)] = refs;
     await chrome.storage.session.set({ tabSnapshotRefs: stored });
-    console.log("[CDPDOMService] Saved refs to storage for tab:", tabId, Object.keys(refs).length);
   } catch (e) {
     console.warn("[CDPDOMService] Failed to save refs to storage:", e);
   }
 }
 loadRefsFromStorage();
+async function buildURLMap(tabId, linkBackendIds) {
+  if (linkBackendIds.size === 0) return /* @__PURE__ */ new Map();
+  const urlMap = /* @__PURE__ */ new Map();
+  try {
+    let walk = function(node) {
+      if (linkBackendIds.has(node.backendNodeId)) {
+        const attrs = node.attributes || [];
+        for (let i = 0; i < attrs.length; i += 2) {
+          if (attrs[i] === "href") {
+            urlMap.set(node.backendNodeId, attrs[i + 1]);
+            break;
+          }
+        }
+      }
+      for (const child of node.children || []) walk(child);
+      if (node.contentDocument) walk(node.contentDocument);
+      for (const shadow of node.shadowRoots || []) walk(shadow);
+    };
+    const doc = await getDocument(tabId, { depth: -1, pierce: true });
+    walk(doc);
+  } catch (e) {
+    console.warn("[CDPDOMService] Failed to build URL map:", e);
+  }
+  return urlMap;
+}
 async function getSnapshot(tabId, options = {}) {
-  console.log("[CDPDOMService] Getting snapshot via legacy method for tab:", tabId);
-  const result = await getSnapshot$1(tabId, options);
+  console.log("[CDPDOMService] Getting snapshot via AX tree for tab:", tabId, options);
+  let axNodes;
+  if (options.selector) {
+    try {
+      const doc = await getDocument(tabId, { depth: 0 });
+      const nodeId = await querySelector(tabId, doc.nodeId, options.selector);
+      if (!nodeId) throw new Error(`Selector "${options.selector}" not found`);
+      axNodes = await getPartialAccessibilityTree(tabId, nodeId);
+    } catch (e) {
+      throw new Error(`Selector "${options.selector}" failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  } else {
+    axNodes = await getFullAccessibilityTree(tabId);
+  }
+  const linkBackendIds = /* @__PURE__ */ new Set();
+  for (const node of axNodes) {
+    if (node.role?.value === "link" && node.backendDOMNodeId !== void 0) {
+      linkBackendIds.add(node.backendDOMNodeId);
+    }
+  }
+  const urlMap = await buildURLMap(tabId, linkBackendIds);
+  const result = formatAXTree(axNodes, urlMap, {
+    interactive: options.interactive,
+    compact: options.compact,
+    maxDepth: options.maxDepth
+  });
   const convertedRefs = {};
-  for (const [refId, refInfo] of Object.entries(result.refs)) {
+  for (const [refId, axRef] of Object.entries(result.refs)) {
     convertedRefs[refId] = {
-      xpath: refInfo.xpath,
-      role: refInfo.role,
-      name: refInfo.name,
-      tagName: refInfo.tagName
+      backendDOMNodeId: axRef.backendDOMNodeId,
+      role: axRef.role,
+      name: axRef.name
     };
   }
-  tabSnapshotRefs.set(tabId, convertedRefs);
+  tabSnapshotRefs$1.set(tabId, convertedRefs);
   await saveRefsToStorage(tabId, convertedRefs);
   console.log("[CDPDOMService] Snapshot complete:", {
     linesCount: result.snapshot.split("\n").length,
     refsCount: Object.keys(convertedRefs).length
   });
-  return {
-    snapshot: result.snapshot,
-    refs: convertedRefs
-  };
+  return { snapshot: result.snapshot, refs: convertedRefs };
+}
+async function getElementCenter(tabId, backendNodeId) {
+  const objectId = await resolveNodeByBackendId(tabId, backendNodeId);
+  if (!objectId) throw new Error("Failed to resolve node");
+  const result = await callFunctionOn(tabId, objectId, `function() {
+    this.scrollIntoView({ behavior: 'auto', block: 'center', inline: 'center' });
+    const rect = this.getBoundingClientRect();
+    return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
+  }`);
+  if (!result || typeof result !== "object") throw new Error("Failed to get element center");
+  return result;
 }
-async function getRefInfo(tabId, ref) {
-  const refId = ref.startsWith("@") ? ref.slice(1) : ref;
-  const refs = tabSnapshotRefs.get(tabId);
-  if (refs?.[refId]) {
-    return refs[refId];
-  }
-  if (!tabSnapshotRefs.has(tabId)) {
-    await loadRefsFromStorage();
-    const loaded = tabSnapshotRefs.get(tabId);
-    if (loaded?.[refId]) {
-      return loaded[refId];
-    }
-  }
-  return null;
+async function evaluateOnElement(tabId, backendNodeId, fn, args = []) {
+  const objectId = await resolveNodeByBackendId(tabId, backendNodeId);
+  if (!objectId) throw new Error("Failed to resolve node");
+  return callFunctionOn(tabId, objectId, fn, args);
 }
-function cleanupTab(tabId) {
-  tabSnapshotRefs.delete(tabId);
-  tabActiveFrameId$1.delete(tabId);
+function getBackendNodeId(refInfo) {
+  return refInfo.backendDOMNodeId ?? 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
+        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,
-      };
+      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}`);
-  }
+  if (!result) throw new Error(`Element not found by xpath: ${xpath}`);
   return result;
 }
+async function getRefInfo(tabId, ref) {
+  const refId = ref.startsWith("@") ? ref.slice(1) : ref;
+  const refs = tabSnapshotRefs$1.get(tabId);
+  if (refs?.[refId]) return refs[refId];
+  if (!tabSnapshotRefs$1.has(tabId)) {
+    await loadRefsFromStorage();
+    const loaded = tabSnapshotRefs$1.get(tabId);
+    if (loaded?.[refId]) return loaded[refId];
+  }
+  return null;
+}
+function cleanupTab$1(tabId) {
+  tabSnapshotRefs$1.delete(tabId);
+  tabActiveFrameId$2.delete(tabId);
+}
 async function clickElement(tabId, ref) {
   const refInfo = await getRefInfo(tabId, ref);
-  if (!refInfo) {
-    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  if (!refInfo) throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  const { role, name } = refInfo;
+  const backendNodeId = getBackendNodeId(refInfo);
+  let x, y;
+  if (backendNodeId !== null) {
+    ({ x, y } = await getElementCenter(tabId, backendNodeId));
+  } else if (refInfo.xpath) {
+    ({ x, y } = await getElementCenterByXPath(tabId, refInfo.xpath));
+  } else {
+    throw new Error(`No locator for ref "${ref}"`);
   }
-  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(tabId, ref);
-  if (!refInfo) {
-    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  if (!refInfo) throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  const { role, name } = refInfo;
+  const backendNodeId = getBackendNodeId(refInfo);
+  let x, y;
+  if (backendNodeId !== null) {
+    ({ x, y } = await getElementCenter(tabId, backendNodeId));
+  } else if (refInfo.xpath) {
+    ({ x, y } = await getElementCenterByXPath(tabId, refInfo.xpath));
+  } else {
+    throw new Error(`No locator for ref "${ref}"`);
   }
-  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(tabId, 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 = '';
+  if (!refInfo) throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  const { role, name } = refInfo;
+  const backendNodeId = getBackendNodeId(refInfo);
+  if (backendNodeId !== null) {
+    await evaluateOnElement(tabId, backendNodeId, `function() {
+      this.scrollIntoView({ behavior: 'auto', block: 'center', inline: 'center' });
+      this.focus();
+      if (this.tagName === 'INPUT' || this.tagName === 'TEXTAREA') {
+        this.value = '';
+      } else if (this.isContentEditable) {
+        this.textContent = '';
       }
-    })()
-  `);
+    }`);
+  } else if (refInfo.xpath) {
+    await evaluate(tabId, `
+      (function() {
+        const result = document.evaluate(${JSON.stringify(refInfo.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 = ''; }
+      })()
+    `);
+  } else {
+    throw new Error(`No locator for ref "${ref}"`);
+  }
   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(tabId, ref);
-  if (!refInfo) {
-    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  if (!refInfo) throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  const { role, name } = refInfo;
+  const backendNodeId = getBackendNodeId(refInfo);
+  if (backendNodeId !== null) {
+    await evaluateOnElement(tabId, backendNodeId, `function() {
+      this.scrollIntoView({ behavior: 'auto', block: 'center', inline: 'center' });
+      this.focus();
+    }`);
+  } else if (refInfo.xpath) {
+    await evaluate(tabId, `
+      (function() {
+        const result = document.evaluate(${JSON.stringify(refInfo.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();
+      })()
+    `);
+  } else {
+    throw new Error(`No locator for ref "${ref}"`);
   }
-  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);
   }
@@ -1092,169 +1248,151 @@ async function typeElement(tabId, ref, text) {
 }
 async function getElementText(tabId, ref) {
   const refInfo = await getRefInfo(tabId, ref);
-  if (!refInfo) {
-    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  if (!refInfo) throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  const backendNodeId = getBackendNodeId(refInfo);
+  let text;
+  if (backendNodeId !== null) {
+    text = await evaluateOnElement(tabId, backendNodeId, `function() {
+      return (this.textContent || '').trim();
+    }`);
+  } else if (refInfo.xpath) {
+    text = await evaluate(tabId, `
+      (function() {
+        const result = document.evaluate(${JSON.stringify(refInfo.xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+        const element = result.singleNodeValue;
+        if (!element) return '';
+        return (element.textContent || '').trim();
+      })()
+    `);
+  } else {
+    throw new Error(`No locator for ref "${ref}"`);
   }
-  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;
+  return text || "";
 }
 async function checkElement(tabId, ref) {
   const refInfo = await getRefInfo(tabId, ref);
-  if (!refInfo) {
-    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  if (!refInfo) throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  const { role, name } = refInfo;
+  const backendNodeId = getBackendNodeId(refInfo);
+  let wasChecked;
+  if (backendNodeId !== null) {
+    wasChecked = await evaluateOnElement(tabId, backendNodeId, `function() {
+      if (this.type !== 'checkbox' && this.type !== 'radio') throw new Error('Element is not a checkbox or radio');
+      const was = this.checked;
+      if (!was) { this.checked = true; this.dispatchEvent(new Event('change', { bubbles: true })); }
+      return was;
+    }`);
+  } else if (refInfo.xpath) {
+    wasChecked = await evaluate(tabId, `
+      (function() {
+        const result = document.evaluate(${JSON.stringify(refInfo.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 was = element.checked;
+        if (!was) { element.checked = true; element.dispatchEvent(new Event('change', { bubbles: true })); }
+        return was;
+      })()
+    `);
+  } else {
+    throw new Error(`No locator for ref "${ref}"`);
   }
-  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 };
+  return { role, name, wasAlreadyChecked: wasChecked };
 }
 async function uncheckElement(tabId, ref) {
   const refInfo = await getRefInfo(tabId, ref);
-  if (!refInfo) {
-    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  if (!refInfo) throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  const { role, name } = refInfo;
+  const backendNodeId = getBackendNodeId(refInfo);
+  let wasUnchecked;
+  if (backendNodeId !== null) {
+    wasUnchecked = await evaluateOnElement(tabId, backendNodeId, `function() {
+      if (this.type !== 'checkbox' && this.type !== 'radio') throw new Error('Element is not a checkbox or radio');
+      const was = !this.checked;
+      if (!was) { this.checked = false; this.dispatchEvent(new Event('change', { bubbles: true })); }
+      return was;
+    }`);
+  } else if (refInfo.xpath) {
+    wasUnchecked = await evaluate(tabId, `
+      (function() {
+        const result = document.evaluate(${JSON.stringify(refInfo.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 was = !element.checked;
+        if (!was) { element.checked = false; element.dispatchEvent(new Event('change', { bubbles: true })); }
+        return was;
+      })()
+    `);
+  } else {
+    throw new Error(`No locator for ref "${ref}"`);
   }
-  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 };
+  return { role, name, wasAlreadyUnchecked: wasUnchecked };
 }
 async function selectOption(tabId, ref, value) {
   const refInfo = await getRefInfo(tabId, 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));
+  if (!refInfo) throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  const { role, name } = refInfo;
+  const backendNodeId = getBackendNodeId(refInfo);
+  const selectFn = `function(selectValue) {
+    if (this.tagName !== 'SELECT') throw new Error('Element is not a <select> element');
+    let matched = null;
+    for (const opt of this.options) {
+      if (opt.value === selectValue || opt.textContent.trim() === selectValue) { matched = opt; break; }
+    }
+    if (!matched) {
+      const lower = selectValue.toLowerCase();
+      for (const opt of this.options) {
+        if (opt.value.toLowerCase() === lower || opt.textContent.trim().toLowerCase() === lower) { matched = opt; break; }
       }
-      
-      element.value = matched.value;
-      element.dispatchEvent(new Event('change', { bubbles: true }));
-      
-      return { selectedValue: matched.value, selectedLabel: matched.textContent.trim() };
-    })()
-  `);
+    }
+    if (!matched) {
+      const available = Array.from(this.options).map(o => ({ value: o.value, label: o.textContent.trim() }));
+      throw new Error('Option not found: ' + selectValue + '. Available: ' + JSON.stringify(available));
+    }
+    this.value = matched.value;
+    this.dispatchEvent(new Event('change', { bubbles: true }));
+    return { selectedValue: matched.value, selectedLabel: matched.textContent.trim() };
+  }`;
+  let result;
+  if (backendNodeId !== null) {
+    result = await evaluateOnElement(tabId, backendNodeId, selectFn, [value]);
+  } else if (refInfo.xpath) {
+    result = await evaluate(tabId, `
+      (function() {
+        const selectValue = ${JSON.stringify(value)};
+        const xpathResult = document.evaluate(${JSON.stringify(refInfo.xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+        const element = xpathResult.singleNodeValue;
+        if (!element) throw new Error('Element not found');
+        return (${selectFn}).call(element, selectValue);
+      })()
+    `);
+  } else {
+    throw new Error(`No locator for ref "${ref}"`);
+  }
   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(tabId, ref);
-  if (!refInfo) {
-    throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
-  }
-  const { xpath } = refInfo;
+  if (!refInfo) throw new Error(`Ref "${ref}" not found. Run snapshot first to get available refs.`);
+  const backendNodeId = getBackendNodeId(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;
+    try {
+      if (backendNodeId !== null) {
+        const objectId = await resolveNodeByBackendId(tabId, backendNodeId);
+        if (objectId) return;
+      } else if (refInfo.xpath) {
+        const found = await evaluate(tabId, `
+          (function() {
+            const result = document.evaluate(${JSON.stringify(refInfo.xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+            return result.singleNodeValue !== null;
+          })()
+        `);
+        if (found) return;
+      }
+    } catch {
     }
     await new Promise((resolve) => setTimeout(resolve, interval));
     elapsed += interval;
@@ -1262,8 +1400,7 @@ async function waitForElement(tabId, ref, maxWait = 1e4, interval = 200) {
   throw new Error(`Timeout waiting for element @${ref} after ${maxWait}ms`);
 }
 function setActiveFrameId(tabId, frameId) {
-  tabActiveFrameId$1.set(tabId, frameId);
-  console.log("[CDPDOMService] Active frame changed:", { tabId, frameId: frameId ?? "main" });
+  tabActiveFrameId$2.set(tabId, frameId);
 }
 async function pressKey(tabId, key, modifiers = []) {
   let modifierFlags = 0;
@@ -1272,7 +1409,6 @@ async function pressKey(tabId, key, modifiers = []) {
   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(
@@ -1299,7 +1435,13 @@ async function scrollPage(tabId, direction, pixels) {
       break;
   }
   await scroll(tabId, x, y, deltaX, deltaY);
-  console.log("[CDPDOMService] Scrolled:", { direction, pixels });
+}
+
+const tabSnapshotRefs = /* @__PURE__ */ new Map();
+const tabActiveFrameId$1 = /* @__PURE__ */ new Map();
+function cleanupTab(tabId) {
+  tabSnapshotRefs.delete(tabId);
+  tabActiveFrameId$1.delete(tabId);
 }
 
 let isRecording = false;
@@ -1600,9 +1742,12 @@ async function handleSnapshot(command) {
     };
   }
   const interactive = command.interactive;
-  console.log("[CommandHandler] Taking snapshot of tab:", activeTab.id, activeTab.url, { interactive });
+  const compact = command.compact;
+  const maxDepth = command.maxDepth;
+  const selector = command.selector;
+  console.log("[CommandHandler] Taking snapshot of tab:", activeTab.id, activeTab.url, { interactive, compact, maxDepth, selector });
   try {
-    const snapshotResult = await getSnapshot(activeTab.id, { interactive });
+    const snapshotResult = await getSnapshot(activeTab.id, { interactive, compact, maxDepth, selector });
     return {
       id: command.id,
       success: true,
@@ -1925,8 +2070,8 @@ async function handleClose(command) {
   console.log("[CommandHandler] Closing tab:", tabId, url);
   try {
     await chrome.tabs.remove(tabId);
-    cleanupTab$1(tabId);
     cleanupTab(tabId);
+    cleanupTab$1(tabId);
     tabActiveFrameId.delete(tabId);
     return {
       id: command.id,
@@ -2478,8 +2623,8 @@ async function handleTabClose(command) {
     const title = targetTab.title || "";
     const url = targetTab.url || "";
     await chrome.tabs.remove(tabId);
-    cleanupTab$1(tabId);
     cleanupTab(tabId);
+    cleanupTab$1(tabId);
     tabActiveFrameId.delete(tabId);
     return {
       id: command.id,
@@ -2735,7 +2880,8 @@ async function handleNetwork(command) {
       case "requests": {
         await enableNetwork(tabId);
         const filter = command.filter;
-        const requests = getNetworkRequests(tabId, filter);
+        const withBody = command.withBody === true;
+        const requests = getNetworkRequests(tabId, filter, withBody);
         const networkRequests = requests.map((r) => ({
           requestId: r.requestId,
           url: r.url,
@@ -2745,7 +2891,18 @@ async function handleNetwork(command) {
           status: r.response?.status,
           statusText: r.response?.statusText,
           failed: r.failed,
-          failureReason: r.failureReason
+          failureReason: r.failureReason,
+          ...withBody ? {
+            requestHeaders: r.requestHeaders,
+            requestBody: r.requestBody,
+            requestBodyTruncated: r.requestBodyTruncated,
+            responseHeaders: r.response?.headers,
+            responseBody: r.response?.body,
+            responseBodyBase64: r.response?.bodyBase64,
+            responseBodyTruncated: r.response?.bodyTruncated,
+            mimeType: r.response?.mimeType,
+            bodyError: r.bodyError
+          } : {}
         }));
         return {
           id: command.id,