bb-browser 0.8.1 → 0.8.3

package/dist/cli.js

@@ -12,9 +12,10 @@ import "./chunk-D4HDZEJT.js";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // packages/cli/src/cdp-client.ts
-import { readFileSync } from "fs";
+import { readFileSync, unlinkSync, writeFileSync } from "fs";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
+import os2 from "os";
 import path2 from "path";
 import { fileURLToPath } from "url";
 import WebSocket from "ws";
@@ -72,6 +73,10 @@ function findBrowserExecutable() {
   if (process.platform === "darwin") {
     const candidates = [
       "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Applications/Google Chrome Dev.app/Contents/MacOS/Google Chrome Dev",
+      "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+      "/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta",
+      "/Applications/Arc.app/Contents/MacOS/Arc",
       "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
       "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
     ];
@@ -159,25 +164,31 @@ async function discoverCdpPort() {
   if (Number.isInteger(explicitPort) && explicitPort > 0 && await canConnect("127.0.0.1", explicitPort)) {
     return { host: "127.0.0.1", port: explicitPort };
   }
+  try {
+    const rawPort = await readFile(MANAGED_PORT_FILE, "utf8");
+    const managedPort = Number.parseInt(rawPort.trim(), 10);
+    if (Number.isInteger(managedPort) && managedPort > 0 && await canConnect("127.0.0.1", managedPort)) {
+      return { host: "127.0.0.1", port: managedPort };
+    }
+  } catch {
+  }
   if (process.argv.includes("--openclaw")) {
     const viaOpenClaw = await tryOpenClaw();
     if (viaOpenClaw && await canConnect(viaOpenClaw.host, viaOpenClaw.port)) {
       return viaOpenClaw;
     }
   }
-  const detectedOpenClaw = await tryOpenClaw();
-  if (detectedOpenClaw && await canConnect(detectedOpenClaw.host, detectedOpenClaw.port)) {
-    return detectedOpenClaw;
+  const launched = await launchManagedBrowser();
+  if (launched) {
+    return launched;
   }
-  try {
-    const rawPort = await readFile(MANAGED_PORT_FILE, "utf8");
-    const managedPort = Number.parseInt(rawPort.trim(), 10);
-    if (Number.isInteger(managedPort) && managedPort > 0 && await canConnect("127.0.0.1", managedPort)) {
-      return { host: "127.0.0.1", port: managedPort };
+  if (!process.argv.includes("--openclaw")) {
+    const detectedOpenClaw = await tryOpenClaw();
+    if (detectedOpenClaw && await canConnect(detectedOpenClaw.host, detectedOpenClaw.port)) {
+      return detectedOpenClaw;
     }
-  } catch {
   }
-  return launchManagedBrowser();
+  return null;
 }
 
 // packages/cli/src/cdp-client.ts
@@ -233,7 +244,10 @@ function connectWebSocket(url) {
   return new Promise((resolve2, reject) => {
     const ws = new WebSocket(url);
     ws.once("open", () => {
-      ws._socket?.unref?.();
+      const socket = ws._socket;
+      if (socket && typeof socket.unref === "function") {
+        socket.unref();
+      }
       resolve2(ws);
     });
     ws.once("error", reject);
@@ -503,27 +517,118 @@ async function ensurePageTarget(targetId) {
     target = targets[targetId] ?? targets.find((item) => Number(item.id) === targetId);
   } else if (typeof targetId === "string") {
     target = targets.find((item) => item.id === targetId);
+    if (!target) {
+      const numericTargetId = Number(targetId);
+      if (!Number.isNaN(numericTargetId)) {
+        target = targets[numericTargetId] ?? targets.find((item) => Number(item.id) === numericTargetId);
+      }
+    }
   }
   target ??= targets[0];
   connectionState.currentTargetId = target.id;
   await attachTarget(target.id);
   return target;
 }
-function parseRef(ref) {
-  const refs = connectionState?.refsByTarget.get(connectionState.currentTargetId ?? "") ?? {};
+async function resolveBackendNodeIdByXPath(targetId, xpath) {
+  await sessionCommand(targetId, "DOM.getDocument", { depth: 0 });
+  const search = await sessionCommand(targetId, "DOM.performSearch", {
+    query: xpath,
+    includeUserAgentShadowDOM: true
+  });
+  try {
+    if (!search.resultCount) {
+      throw new Error(`Unknown ref xpath: ${xpath}`);
+    }
+    const { nodeIds } = await sessionCommand(targetId, "DOM.getSearchResults", {
+      searchId: search.searchId,
+      fromIndex: 0,
+      toIndex: search.resultCount
+    });
+    for (const nodeId of nodeIds) {
+      const described = await sessionCommand(targetId, "DOM.describeNode", {
+        nodeId
+      });
+      if (described.node.backendNodeId) {
+        return described.node.backendNodeId;
+      }
+    }
+    throw new Error(`XPath resolved but no backend node id found: ${xpath}`);
+  } finally {
+    await sessionCommand(targetId, "DOM.discardSearchResults", { searchId: search.searchId }).catch(() => {
+    });
+  }
+}
+async function parseRef(ref) {
+  const targetId = connectionState?.currentTargetId ?? "";
+  let refs = connectionState?.refsByTarget.get(targetId) ?? {};
+  if (!refs[ref] && targetId) {
+    const persistedRefs = loadPersistedRefs(targetId);
+    if (persistedRefs) {
+      connectionState?.refsByTarget.set(targetId, persistedRefs);
+      refs = persistedRefs;
+    }
+  }
   const found = refs[ref];
-  if (!found?.backendDOMNodeId) {
+  if (!found) {
     throw new Error(`Unknown ref: ${ref}. Run snapshot first.`);
   }
-  return found.backendDOMNodeId;
+  if (found.backendDOMNodeId) {
+    return found.backendDOMNodeId;
+  }
+  if (targetId && found.xpath) {
+    const backendDOMNodeId = await resolveBackendNodeIdByXPath(targetId, found.xpath);
+    found.backendDOMNodeId = backendDOMNodeId;
+    connectionState?.refsByTarget.set(targetId, refs);
+    const pageUrl = await evaluate(targetId, "location.href", true).catch(() => void 0);
+    if (pageUrl) {
+      persistRefs(targetId, pageUrl, refs);
+    }
+    return backendDOMNodeId;
+  }
+  throw new Error(`Unknown ref: ${ref}. Run snapshot first.`);
+}
+function getRefsFilePath(targetId) {
+  return path2.join(os2.tmpdir(), `bb-browser-refs-${targetId}.json`);
+}
+function loadPersistedRefs(targetId, expectedUrl) {
+  try {
+    const data = JSON.parse(readFileSync(getRefsFilePath(targetId), "utf-8"));
+    if (data.targetId !== targetId) return null;
+    if (expectedUrl !== void 0 && data.url !== expectedUrl) return null;
+    if (!data.refs || typeof data.refs !== "object") return null;
+    return data.refs;
+  } catch {
+    return null;
+  }
+}
+function persistRefs(targetId, url, refs) {
+  try {
+    writeFileSync(getRefsFilePath(targetId), JSON.stringify({ targetId, url, timestamp: Date.now(), refs }));
+  } catch {
+  }
+}
+function clearPersistedRefs(targetId) {
+  try {
+    unlinkSync(getRefsFilePath(targetId));
+  } catch {
+  }
 }
 function loadBuildDomTreeScript() {
   const currentDir = path2.dirname(fileURLToPath(import.meta.url));
   const candidates = [
+    path2.resolve(currentDir, "./extension/buildDomTree.js"),
+    // npm installed: dist/cli.js → ../extension/buildDomTree.js
+    path2.resolve(currentDir, "../extension/buildDomTree.js"),
+    path2.resolve(currentDir, "../extension/dist/buildDomTree.js"),
+    path2.resolve(currentDir, "../packages/extension/public/buildDomTree.js"),
+    path2.resolve(currentDir, "../packages/extension/dist/buildDomTree.js"),
+    // dev mode: packages/cli/dist/ → ../../../extension/
     path2.resolve(currentDir, "../../../extension/buildDomTree.js"),
+    path2.resolve(currentDir, "../../../extension/dist/buildDomTree.js"),
+    // dev mode: packages/cli/src/ → ../../extension/
     path2.resolve(currentDir, "../../extension/buildDomTree.js"),
-    path2.resolve(currentDir, "../../../packages/extension/buildDomTree.js"),
-    path2.resolve(currentDir, "../../../extension/dist/buildDomTree.js")
+    path2.resolve(currentDir, "../../../packages/extension/dist/buildDomTree.js"),
+    path2.resolve(currentDir, "../../../packages/extension/public/buildDomTree.js")
   ];
   for (const candidate of candidates) {
     try {
@@ -551,8 +656,34 @@ async function resolveNode(targetId, backendNodeId) {
   return result.nodeId;
 }
 async function focusNode(targetId, backendNodeId) {
-  const nodeId = await resolveNode(targetId, backendNodeId);
-  await sessionCommand(targetId, "DOM.focus", { nodeId });
+  await sessionCommand(targetId, "DOM.focus", { backendNodeId });
+}
+async function insertTextIntoNode(targetId, backendNodeId, text, clearFirst) {
+  const resolved = await sessionCommand(targetId, "DOM.resolveNode", { backendNodeId });
+  await sessionCommand(targetId, "Runtime.callFunctionOn", {
+    objectId: resolved.object.objectId,
+    functionDeclaration: `function(value, clearFirst) {
+      if (typeof this.focus === 'function') this.focus();
+      if (clearFirst && ('value' in this)) {
+        this.value = '';
+        this.dispatchEvent(new Event('input', { bubbles: true }));
+      }
+      if ('value' in this) {
+        this.value = clearFirst ? value : String(this.value ?? '') + value;
+        this.dispatchEvent(new Event('input', { bubbles: true }));
+        this.dispatchEvent(new Event('change', { bubbles: true }));
+        return true;
+      }
+      return false;
+    }`,
+    arguments: [
+      { value: text },
+      { value: clearFirst }
+    ],
+    returnByValue: true
+  });
+  await focusNode(targetId, backendNodeId);
+  await sessionCommand(targetId, "Input.insertText", { text });
 }
 async function getNodeBox(targetId, backendNodeId) {
   const result = await sessionCommand(targetId, "DOM.getBoxModel", {
@@ -586,15 +717,181 @@ async function getAttributeValue(targetId, backendNodeId, attribute) {
 }
 async function buildSnapshot(targetId, request) {
   const script = loadBuildDomTreeScript();
-  const expression = `(() => { ${script}; return (typeof buildDomTree === 'function' ? buildDomTree : globalThis.buildDomTree)(${JSON.stringify({
+  const buildArgs = {
+    showHighlightElements: true,
+    focusHighlightIndex: -1,
+    viewportExpansion: -1,
+    debugMode: false,
+    startId: 0,
+    startHighlightIndex: 0
+  };
+  const expression = `(() => { ${script}; const fn = globalThis.buildDomTree ?? (typeof window !== 'undefined' ? window.buildDomTree : undefined); if (typeof fn !== 'function') { throw new Error('buildDomTree is not available after script injection'); } return fn(${JSON.stringify({
+    ...buildArgs
+  })}); })()`;
+  const value = await evaluate(targetId, expression, true);
+  if (!value || !value.map || !value.rootId) {
+    const title = await evaluate(targetId, "document.title", true);
+    const pageUrl2 = await evaluate(targetId, "location.href", true);
+    const fallbackSnapshot = {
+      title,
+      url: pageUrl2,
+      lines: [title || pageUrl2],
+      refs: {}
+    };
+    connectionState?.refsByTarget.set(targetId, {});
+    persistRefs(targetId, pageUrl2, {});
+    return fallbackSnapshot;
+  }
+  const snapshot = convertBuildDomTreeResult(value, {
     interactiveOnly: !!request.interactive,
     compact: !!request.compact,
     maxDepth: request.maxDepth,
     selector: request.selector
-  })}); })()`;
-  const value = await evaluate(targetId, expression, true);
-  connectionState?.refsByTarget.set(targetId, value.refs || {});
-  return value;
+  });
+  const pageUrl = await evaluate(targetId, "location.href", true);
+  connectionState?.refsByTarget.set(targetId, snapshot.refs || {});
+  persistRefs(targetId, pageUrl, snapshot.refs || {});
+  return snapshot;
+}
+function convertBuildDomTreeResult(result, options) {
+  const { interactiveOnly, compact, maxDepth, selector } = options;
+  const { rootId, map } = result;
+  const refs = {};
+  const lines = [];
+  const getRole = (node) => {
+    const tagName = node.tagName.toLowerCase();
+    const role = node.attributes?.role;
+    if (role) return role;
+    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"
+    };
+    const roleMap = {
+      a: "link",
+      button: "button",
+      input: inputRoleMap[type] || "textbox",
+      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;
+  };
+  const collectTextContent = (node, nodeMap, depthLimit = 5) => {
+    const texts = [];
+    const visit = (nodeId, depth) => {
+      if (depth > depthLimit) 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;
+      }
+      for (const childId of currentNode.children || []) visit(childId, depth + 1);
+    };
+    for (const childId of node.children || []) visit(childId, 0);
+    return texts.join(" ").trim();
+  };
+  const getName = (node) => {
+    const attrs = node.attributes || {};
+    return attrs["aria-label"] || attrs.title || attrs.placeholder || attrs.alt || attrs.value || collectTextContent(node, map) || attrs.name || void 0;
+  };
+  const truncateText = (text, length = 50) => text.length <= length ? text : `${text.slice(0, length - 3)}...`;
+  const selectorText = selector?.trim().toLowerCase();
+  const matchesSelector = (node, role, name) => {
+    if (!selectorText) return true;
+    const haystack = [node.tagName, role, name, node.xpath || "", ...Object.values(node.attributes || {})].join(" ").toLowerCase();
+    return haystack.includes(selectorText);
+  };
+  if (interactiveOnly) {
+    const interactiveNodes = Object.entries(map).filter(([, node]) => !("type" in node) && node.highlightIndex !== void 0 && node.highlightIndex !== null).map(([id, node]) => ({ id, node })).sort((a, b) => (a.node.highlightIndex ?? 0) - (b.node.highlightIndex ?? 0));
+    for (const { node } of interactiveNodes) {
+      const refId = String(node.highlightIndex);
+      const role = getRole(node);
+      const name = getName(node);
+      if (!matchesSelector(node, role, name)) continue;
+      let line = `${role} [ref=${refId}]`;
+      if (name) line += ` ${JSON.stringify(truncateText(name))}`;
+      lines.push(line);
+      refs[refId] = {
+        xpath: node.xpath || "",
+        role,
+        name,
+        tagName: node.tagName.toLowerCase()
+      };
+    }
+    return { snapshot: lines.join("\n"), refs };
+  }
+  const walk = (nodeId, depth) => {
+    if (maxDepth !== void 0 && depth > maxDepth) return;
+    const node = map[nodeId];
+    if (!node) return;
+    if ("type" in node && node.type === "TEXT_NODE") {
+      const text = node.text.trim();
+      if (!text) return;
+      lines.push(`${"  ".repeat(depth)}- text ${JSON.stringify(truncateText(text, compact ? 80 : 120))}`);
+      return;
+    }
+    const role = getRole(node);
+    const name = getName(node);
+    if (!matchesSelector(node, role, name)) {
+      for (const childId of node.children || []) walk(childId, depth + 1);
+      return;
+    }
+    const indent = "  ".repeat(depth);
+    const refId = node.highlightIndex !== void 0 && node.highlightIndex !== null ? String(node.highlightIndex) : null;
+    let line = `${indent}- ${role}`;
+    if (refId) line += ` [ref=${refId}]`;
+    if (name) line += ` ${JSON.stringify(truncateText(name, compact ? 50 : 80))}`;
+    if (!compact) line += ` <${node.tagName.toLowerCase()}>`;
+    lines.push(line);
+    if (refId) {
+      refs[refId] = {
+        xpath: node.xpath || "",
+        role,
+        name,
+        tagName: node.tagName.toLowerCase()
+      };
+    }
+    for (const childId of node.children || []) walk(childId, depth + 1);
+  };
+  walk(rootId, 0);
+  return { snapshot: lines.join("\n"), refs };
 }
 function ok(id, data) {
   return { id, success: true, data };
@@ -638,10 +935,12 @@ async function dispatchRequest(request) {
       if (request.tabId === void 0) {
         const created = await browserCommand("Target.createTarget", { url: request.url });
         const newTarget = await ensurePageTarget(created.targetId);
-        return ok(request.id, { url: request.url, tabId: Number(newTarget.id) || void 0 });
+        return ok(request.id, { url: request.url, tabId: newTarget.id });
       }
       await pageCommand(target.id, "Page.navigate", { url: request.url });
-      return ok(request.id, { url: request.url, title: target.title, tabId: Number(target.id) || void 0 });
+      connectionState?.refsByTarget.delete(target.id);
+      clearPersistedRefs(target.id);
+      return ok(request.id, { url: request.url, title: target.title, tabId: target.id });
     }
     case "snapshot": {
       const snapshotData = await buildSnapshot(target.id, request);
@@ -650,7 +949,7 @@ async function dispatchRequest(request) {
     case "click":
     case "hover": {
       if (!request.ref) return fail(request.id, "Missing ref parameter");
-      const backendNodeId = parseRef(request.ref);
+      const backendNodeId = await parseRef(request.ref);
       const point = await getNodeBox(target.id, backendNodeId);
       await sessionCommand(target.id, "Input.dispatchMouseEvent", { type: "mouseMoved", x: point.x, y: point.y, button: "none" });
       if (request.action === "click") await mouseClick(target.id, point.x, point.y);
@@ -660,18 +959,14 @@ async function dispatchRequest(request) {
     case "type": {
       if (!request.ref) return fail(request.id, "Missing ref parameter");
       if (request.text == null) return fail(request.id, "Missing text parameter");
-      const backendNodeId = parseRef(request.ref);
-      await focusNode(target.id, backendNodeId);
-      if (request.action === "fill") {
-        await evaluate(target.id, `document.activeElement && ((document.activeElement.value = ''), document.activeElement.dispatchEvent(new Event('input', { bubbles: true })))`);
-      }
-      await sessionCommand(target.id, "Input.insertText", { text: request.text });
+      const backendNodeId = await parseRef(request.ref);
+      await insertTextIntoNode(target.id, backendNodeId, request.text, request.action === "fill");
       return ok(request.id, { value: request.text });
     }
     case "check":
     case "uncheck": {
       if (!request.ref) return fail(request.id, "Missing ref parameter");
-      const backendNodeId = parseRef(request.ref);
+      const backendNodeId = await parseRef(request.ref);
       const desired = request.action === "check";
       const resolved = await sessionCommand(target.id, "DOM.resolveNode", { backendNodeId });
       await sessionCommand(target.id, "Runtime.callFunctionOn", {
@@ -682,7 +977,7 @@ async function dispatchRequest(request) {
     }
     case "select": {
       if (!request.ref || request.value == null) return fail(request.id, "Missing ref or value parameter");
-      const backendNodeId = parseRef(request.ref);
+      const backendNodeId = await parseRef(request.ref);
       const resolved = await sessionCommand(target.id, "DOM.resolveNode", { backendNodeId });
       await sessionCommand(target.id, "Runtime.callFunctionOn", {
         objectId: resolved.object.objectId,
@@ -692,7 +987,7 @@ async function dispatchRequest(request) {
     }
     case "get": {
       if (!request.ref || !request.attribute) return fail(request.id, "Missing ref or attribute parameter");
-      const value = await getAttributeValue(target.id, parseRef(request.ref), request.attribute);
+      const value = await getAttributeValue(target.id, await parseRef(request.ref), request.attribute);
       return ok(request.id, { value });
     }
     case "screenshot": {
@@ -701,6 +996,8 @@ async function dispatchRequest(request) {
     }
     case "close": {
       await browserCommand("Target.closeTarget", { targetId: target.id });
+      connectionState?.refsByTarget.delete(target.id);
+      clearPersistedRefs(target.id);
       return ok(request.id, {});
     }
     case "wait": {
@@ -739,12 +1036,12 @@ async function dispatchRequest(request) {
       return ok(request.id, { result });
     }
     case "tab_list": {
-      const tabs = (await getTargets()).filter((item) => item.type === "page").map((item, index) => ({ index, url: item.url, title: item.title, active: item.id === connectionState?.currentTargetId || !connectionState?.currentTargetId && index === 0, tabId: Number(item.id) || index }));
+      const tabs = (await getTargets()).filter((item) => item.type === "page").map((item, index) => ({ index, url: item.url, title: item.title, active: item.id === connectionState?.currentTargetId || !connectionState?.currentTargetId && index === 0, tabId: item.id }));
       return ok(request.id, { tabs, activeIndex: tabs.findIndex((tab) => tab.active) });
     }
     case "tab_new": {
       const created = await browserCommand("Target.createTarget", { url: request.url ?? "about:blank" });
-      return ok(request.id, { tabId: Number(created.targetId) || void 0, url: request.url ?? "about:blank" });
+      return ok(request.id, { tabId: created.targetId, url: request.url ?? "about:blank" });
     }
     case "tab_select": {
       const tabs = (await getTargets()).filter((item) => item.type === "page");
@@ -752,14 +1049,16 @@ async function dispatchRequest(request) {
       if (!selected) return fail(request.id, "Tab not found");
       connectionState.currentTargetId = selected.id;
       await attachTarget(selected.id);
-      return ok(request.id, { tabId: Number(selected.id) || void 0, url: selected.url, title: selected.title });
+      return ok(request.id, { tabId: selected.id, url: selected.url, title: selected.title });
     }
     case "tab_close": {
       const tabs = (await getTargets()).filter((item) => item.type === "page");
       const selected = request.tabId !== void 0 ? tabs.find((item) => item.id === String(request.tabId) || Number(item.id) === request.tabId) : tabs[request.index ?? 0];
       if (!selected) return fail(request.id, "Tab not found");
       await browserCommand("Target.closeTarget", { targetId: selected.id });
-      return ok(request.id, { tabId: Number(selected.id) || void 0 });
+      connectionState?.refsByTarget.delete(selected.id);
+      clearPersistedRefs(selected.id);
+      return ok(request.id, { tabId: selected.id });
     }
     case "frame": {
       if (!request.selector) return fail(request.id, "Missing selector parameter");
@@ -891,9 +1190,6 @@ async function sendCommand2(request) {
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname, resolve } from "path";
 import { existsSync as existsSync2 } from "fs";
-async function isDaemonRunning() {
-  return await discoverCdpPort() !== null;
-}
 async function ensureDaemonRunning() {
   try {
     await ensureCdpConnection();
@@ -911,7 +1207,7 @@ async function ensureDaemonRunning() {
 }
 
 // packages/cli/src/history-sqlite.ts
-import { copyFileSync, existsSync as existsSync3, unlinkSync } from "fs";
+import { copyFileSync, existsSync as existsSync3, unlinkSync as unlinkSync2 } from "fs";
 import { execSync as execSync2 } from "child_process";
 import { homedir, tmpdir } from "os";
 import { join } from "path";
@@ -969,7 +1265,7 @@ function runHistoryQuery(sql, mapRow) {
     return [];
   } finally {
     try {
-      unlinkSync(tmpPath);
+      unlinkSync2(tmpPath);
     } catch {
     }
   }
@@ -1960,11 +2256,11 @@ async function getCommand(attribute, ref, options = {}) {
 // packages/cli/src/commands/screenshot.ts
 import fs from "fs";
 import path3 from "path";
-import os2 from "os";
+import os3 from "os";
 function getDefaultPath() {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const filename = `bb-screenshot-${timestamp}.png`;
-  return path3.join(os2.tmpdir(), filename);
+  return path3.join(os3.tmpdir(), filename);
 }
 function saveBase64Image(dataUrl, filePath) {
   const base64Data = dataUrl.replace(/^data:image\/png;base64,/, "");
@@ -2140,123 +2436,6 @@ async function scrollCommand(direction, pixels, options = {}) {
   }
 }
 
-// packages/cli/src/commands/daemon.ts
-async function statusCommand(options = {}) {
-  const running = await isDaemonRunning();
-  if (options.json) {
-    console.log(JSON.stringify({ running }));
-  } else {
-    console.log(running ? "\u6D4F\u89C8\u5668\u8FD0\u884C\u4E2D" : "\u6D4F\u89C8\u5668\u672A\u8FD0\u884C");
-  }
-}
-
-// packages/cli/src/commands/reload.ts
-import WebSocket2 from "ws";
-var EXTENSION_NAME = "bb-browser";
-async function reloadCommand(options = {}) {
-  const port = options.port || 9222;
-  try {
-    const listRes = await fetch(`http://127.0.0.1:${port}/json/list`);
-    if (!listRes.ok) {
-      throw new Error(`CDP \u672A\u542F\u7528\u3002\u8BF7\u7528 --remote-debugging-port=${port} \u542F\u52A8 Chrome`);
-    }
-    const list = await listRes.json();
-    const extPage = list.find(
-      (t) => t.type === "page" && t.url.includes("chrome://extensions")
-    );
-    if (!extPage) {
-      throw new Error("\u8BF7\u5148\u6253\u5F00 chrome://extensions \u9875\u9762");
-    }
-    const result = await new Promise((resolve2, reject) => {
-      const ws = new WebSocket2(extPage.webSocketDebuggerUrl);
-      let resolved = false;
-      const timeout = setTimeout(() => {
-        if (!resolved) {
-          resolved = true;
-          ws.close();
-          reject(new Error("CDP \u8FDE\u63A5\u8D85\u65F6"));
-        }
-      }, 1e4);
-      ws.on("open", () => {
-        const script = `
-          (async function() {
-            if (!chrome || !chrome.developerPrivate) {
-              return { error: 'developerPrivate API not available' };
-            }
-            
-            try {
-              const exts = await chrome.developerPrivate.getExtensionsInfo();
-              const bbExt = exts.find(e => e.name === '${EXTENSION_NAME}');
-              
-              if (!bbExt) {
-                return { error: '${EXTENSION_NAME} \u6269\u5C55\u672A\u5B89\u88C5' };
-              }
-              
-              if (bbExt.state !== 'ENABLED') {
-                return { error: '${EXTENSION_NAME} \u6269\u5C55\u5DF2\u7981\u7528' };
-              }
-              
-              await chrome.developerPrivate.reload(bbExt.id, {failQuietly: true});
-              return { success: true, extensionId: bbExt.id };
-            } catch (e) {
-              return { error: e.message };
-            }
-          })()
-        `;
-        ws.send(JSON.stringify({
-          id: 1,
-          method: "Runtime.evaluate",
-          params: {
-            expression: script,
-            awaitPromise: true,
-            returnByValue: true
-          }
-        }));
-      });
-      ws.on("message", (data) => {
-        const msg = JSON.parse(data.toString());
-        if (msg.id === 1) {
-          clearTimeout(timeout);
-          resolved = true;
-          ws.close();
-          const value = msg.result?.result?.value;
-          if (value?.success) {
-            resolve2({
-              success: true,
-              message: "\u6269\u5C55\u5DF2\u91CD\u8F7D",
-              extensionId: value.extensionId
-            });
-          } else if (value?.error) {
-            reject(new Error(value.error));
-          } else {
-            reject(new Error(`\u91CD\u8F7D\u5931\u8D25: ${JSON.stringify(value)}`));
-          }
-        }
-      });
-      ws.on("error", (err) => {
-        clearTimeout(timeout);
-        if (!resolved) {
-          resolved = true;
-          reject(new Error(`CDP \u8FDE\u63A5\u5931\u8D25: ${err.message}`));
-        }
-      });
-    });
-    if (options.json) {
-      console.log(JSON.stringify(result));
-    } else {
-      console.log(`${result.message} (${result.extensionId})`);
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (options.json) {
-      console.log(JSON.stringify({ success: false, error: message }));
-    } else {
-      console.error(`\u9519\u8BEF: ${message}`);
-    }
-    process.exit(1);
-  }
-}
-
 // packages/cli/src/commands/nav.ts
 async function backCommand(options = {}) {
   await ensureDaemonRunning();
@@ -2510,6 +2689,9 @@ function parseTabSubcommand(args, rawArgv) {
     return { action: "tab_list" };
   }
   const first = args[0];
+  if (first === "list") {
+    return { action: "tab_list" };
+  }
   if (first === "new") {
     return { action: "tab_new", url: args[1] };
   }
@@ -3038,9 +3220,9 @@ async function fetchCommand(url, options = {}) {
     throw new Error(`Fetch error: ${result.error}`);
   }
   if (options.output) {
-    const { writeFileSync } = await import("fs");
+    const { writeFileSync: writeFileSync2 } = await import("fs");
     const content = typeof result.body === "object" ? JSON.stringify(result.body, null, 2) : String(result.body);
-    writeFileSync(options.output, content, "utf-8");
+    writeFileSync2(options.output, content, "utf-8");
     console.log(`\u5DF2\u5199\u5165 ${options.output} (${result.status}, ${content.length} bytes)`);
     return;
   }
@@ -3101,7 +3283,7 @@ async function historyCommand(subCommand, options = {}) {
 }
 
 // packages/cli/src/index.ts
-var VERSION = "0.8.0";
+var VERSION = "0.8.2";
 var HELP_TEXT = `
 bb-browser - AI Agent \u6D4F\u89C8\u5668\u81EA\u52A8\u5316\u5DE5\u5177
 
@@ -3419,24 +3601,6 @@ async function main() {
         break;
       }
       case "daemon":
-      case "start": {
-        const hostIdx = process.argv.findIndex((a) => a === "--host");
-        const host = hostIdx >= 0 ? process.argv[hostIdx + 1] : void 0;
-        await daemonCommand({ json: parsed.flags.json, host });
-        break;
-      }
-      case "stop": {
-        await stopCommand({ json: parsed.flags.json });
-        break;
-      }
-      case "status": {
-        await statusCommand({ json: parsed.flags.json });
-        break;
-      }
-      case "reload": {
-        await reloadCommand({ json: parsed.flags.json });
-        break;
-      }
       case "close": {
         await closeCommand({ json: parsed.flags.json, tabId: globalTabId });
         break;