bb-browser 0.10.1 → 0.11.1

package/dist/cli.js

@@ -2,7 +2,7 @@
 import {
   COMMAND_TIMEOUT,
   generateId
-} from "./chunk-XYKHDJST.js";
+} from "./chunk-H2VEQBAU.js";
 import {
   applyJq
 } from "./chunk-AHGAQEFO.js";
@@ -12,16 +12,17 @@ import {
 import "./chunk-D4HDZEJT.js";
 
 // packages/cli/src/index.ts
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
-// packages/cli/src/cdp-client.ts
-import { readFileSync, unlinkSync, writeFileSync } from "fs";
+// packages/cli/src/daemon-manager.ts
+import { spawn as spawn2 } from "child_process";
+import { readFile as readFile2, unlink } from "fs/promises";
 import { request as httpRequest } from "http";
-import { request as httpsRequest } from "https";
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+import { existsSync as existsSync2 } from "fs";
 import os2 from "os";
 import path2 from "path";
-import { fileURLToPath } from "url";
-import WebSocket from "ws";
 
 // packages/cli/src/cdp-discovery.ts
 import { execFile, execSync, spawn } from "child_process";
@@ -33,14 +34,16 @@ var DEFAULT_CDP_PORT = 19825;
 var MANAGED_BROWSER_DIR = path.join(os.homedir(), ".bb-browser", "browser");
 var MANAGED_USER_DATA_DIR = path.join(MANAGED_BROWSER_DIR, "user-data");
 var MANAGED_PORT_FILE = path.join(MANAGED_BROWSER_DIR, "cdp-port");
+var CDP_CACHE_FILE = path.join(os.tmpdir(), "bb-browser-cdp-cache.json");
+var CACHE_TTL_MS = 3e4;
 function execFileAsync(command, args, timeout) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve2, reject) => {
     execFile(command, args, { encoding: "utf8", timeout }, (error, stdout) => {
       if (error) {
         reject(error);
         return;
       }
-      resolve3(stdout.trim());
+      resolve2(stdout.trim());
     });
   });
 }
@@ -51,12 +54,33 @@ function getArgValue(flag) {
 }
 async function tryOpenClaw() {
   try {
-    const raw = await execFileAsync("npx", ["openclaw", "browser", "status", "--json"], 5e3);
+    const raw = await execFileAsync("npx", ["openclaw", "browser", "status", "--json"], 3e4);
     const parsed = parseOpenClawJson(raw);
-    const port = Number(parsed?.cdpPort);
-    if (Number.isInteger(port) && port > 0) {
-      return { host: "127.0.0.1", port };
+    let result = null;
+    if (parsed?.cdpUrl) {
+      try {
+        const url = new URL(parsed.cdpUrl);
+        const port = Number(url.port);
+        if (Number.isInteger(port) && port > 0) {
+          result = { host: url.hostname, port };
+        }
+      } catch {
+      }
+    }
+    if (!result) {
+      const port = Number(parsed?.cdpPort);
+      if (Number.isInteger(port) && port > 0) {
+        const host = parsed?.cdpHost || "127.0.0.1";
+        result = { host, port };
+      }
     }
+    if (result) {
+      try {
+        await writeFile(CDP_CACHE_FILE, JSON.stringify({ ...result, timestamp: Date.now() }), "utf8");
+      } catch {
+      }
+    }
+    return result;
   } catch {
   }
   return null;
@@ -116,18 +140,6 @@ function findBrowserExecutable() {
   }
   return null;
 }
-async function isManagedBrowserRunning() {
-  try {
-    const rawPort = await readFile(MANAGED_PORT_FILE, "utf8");
-    const port = Number.parseInt(rawPort.trim(), 10);
-    if (!Number.isInteger(port) || port <= 0) {
-      return false;
-    }
-    return await canConnect("127.0.0.1", port);
-  } catch {
-    return false;
-  }
-}
 async function launchManagedBrowser(port = DEFAULT_CDP_PORT) {
   const executable = findBrowserExecutable();
   if (!executable) {
@@ -178,11 +190,22 @@ async function launchManagedBrowser(port = DEFAULT_CDP_PORT) {
     if (await canConnect("127.0.0.1", port)) {
       return { host: "127.0.0.1", port };
     }
-    await new Promise((resolve3) => setTimeout(resolve3, 250));
+    await new Promise((resolve2) => setTimeout(resolve2, 250));
   }
   return null;
 }
 async function discoverCdpPort() {
+  const envUrl = process.env.BB_BROWSER_CDP_URL;
+  if (envUrl) {
+    try {
+      const url = new URL(envUrl);
+      const port = Number(url.port);
+      if (Number.isInteger(port) && port > 0 && await canConnect(url.hostname, port)) {
+        return { host: url.hostname, port };
+      }
+    } catch {
+    }
+  }
   const explicitPort = Number.parseInt(getArgValue("--port") ?? "", 10);
   if (Number.isInteger(explicitPort) && explicitPort > 0 && await canConnect("127.0.0.1", explicitPort)) {
     return { host: "127.0.0.1", port: explicitPort };
@@ -195,6 +218,14 @@ async function discoverCdpPort() {
     }
   } catch {
   }
+  try {
+    const cacheRaw = await readFile(CDP_CACHE_FILE, "utf8");
+    const cache = JSON.parse(cacheRaw);
+    if (Date.now() - cache.timestamp < CACHE_TTL_MS && await canConnect(cache.host, cache.port)) {
+      return { host: cache.host, port: cache.port };
+    }
+  } catch {
+  }
   if (process.argv.includes("--openclaw")) {
     const viaOpenClaw = await tryOpenClaw();
     if (viaOpenClaw && await canConnect(viaOpenClaw.host, viaOpenClaw.port)) {
@@ -214,1089 +245,36 @@ async function discoverCdpPort() {
   return null;
 }
 
-// packages/cli/src/cdp-client.ts
-var connectionState = null;
-var reconnecting = null;
-var networkRequests = /* @__PURE__ */ new Map();
-var networkEnabled = false;
-var consoleMessages = [];
-var consoleEnabled = false;
-var jsErrors = [];
-var errorsEnabled = false;
-var traceRecording = false;
-var traceEvents = [];
-function getContextFilePath(host, port) {
-  const safeHost = host.replace(/[^a-zA-Z0-9_.-]/g, "_");
-  return path2.join(os2.tmpdir(), `bb-browser-cdp-context-${safeHost}-${port}.json`);
-}
-function loadPersistedCurrentTargetId(host, port) {
-  try {
-    const data = JSON.parse(readFileSync(getContextFilePath(host, port), "utf-8"));
-    return typeof data.currentTargetId === "string" && data.currentTargetId ? data.currentTargetId : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function persistCurrentTargetId(host, port, currentTargetId) {
-  try {
-    writeFileSync(getContextFilePath(host, port), JSON.stringify({ currentTargetId }));
-  } catch {
-  }
-}
-function setCurrentTargetId(targetId) {
-  const state = connectionState;
-  if (!state) return;
-  state.currentTargetId = targetId;
-  persistCurrentTargetId(state.host, state.port, targetId);
-}
-function buildRequestError(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
-function fetchJson(url) {
-  return new Promise((resolve3, reject) => {
-    const requester = url.startsWith("https:") ? httpsRequest : httpRequest;
-    const req = requester(url, { method: "GET" }, (res) => {
-      const chunks = [];
-      res.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-      res.on("end", () => {
-        const raw = Buffer.concat(chunks).toString("utf8");
-        if ((res.statusCode ?? 500) >= 400) {
-          reject(new Error(`HTTP ${res.statusCode ?? 500}: ${raw}`));
-          return;
-        }
-        try {
-          resolve3(JSON.parse(raw));
-        } catch (error) {
-          reject(error);
-        }
-      });
-    });
-    req.on("error", reject);
-    req.end();
-  });
-}
-async function getJsonList(host, port) {
-  const data = await fetchJson(`http://${host}:${port}/json/list`);
-  return Array.isArray(data) ? data : [];
-}
-async function getJsonVersion(host, port) {
-  const data = await fetchJson(`http://${host}:${port}/json/version`);
-  const url = data.webSocketDebuggerUrl;
-  if (typeof url !== "string" || !url) {
-    throw new Error("CDP endpoint missing webSocketDebuggerUrl");
-  }
-  return { webSocketDebuggerUrl: url };
-}
-function connectWebSocket(url) {
-  return new Promise((resolve3, reject) => {
-    const ws = new WebSocket(url);
-    ws.once("open", () => {
-      const socket = ws._socket;
-      if (socket && typeof socket.unref === "function") {
-        socket.unref();
-      }
-      resolve3(ws);
-    });
-    ws.once("error", reject);
-  });
-}
-function createState(host, port, browserWsUrl, browserSocket) {
-  const state = {
-    host,
-    port,
-    browserWsUrl,
-    browserSocket,
-    browserPending: /* @__PURE__ */ new Map(),
-    nextMessageId: 1,
-    sessions: /* @__PURE__ */ new Map(),
-    attachedTargets: /* @__PURE__ */ new Map(),
-    refsByTarget: /* @__PURE__ */ new Map(),
-    currentTargetId: loadPersistedCurrentTargetId(host, port),
-    activeFrameIdByTarget: /* @__PURE__ */ new Map(),
-    dialogHandlers: /* @__PURE__ */ new Map()
-  };
-  browserSocket.on("message", (raw) => {
-    const message = JSON.parse(raw.toString());
-    if (typeof message.id === "number") {
-      const pending = state.browserPending.get(message.id);
-      if (!pending) return;
-      state.browserPending.delete(message.id);
-      if (message.error) {
-        pending.reject(new Error(`${pending.method}: ${message.error.message ?? "Unknown CDP error"}`));
-      } else {
-        pending.resolve(message.result);
-      }
-      return;
-    }
-    if (message.method === "Target.attachedToTarget") {
-      const params = message.params;
-      const sessionId = params.sessionId;
-      const targetInfo = params.targetInfo;
-      if (typeof sessionId === "string" && typeof targetInfo?.targetId === "string") {
-        state.sessions.set(targetInfo.targetId, sessionId);
-        state.attachedTargets.set(sessionId, targetInfo.targetId);
-      }
-      return;
-    }
-    if (message.method === "Target.detachedFromTarget") {
-      const params = message.params;
-      const sessionId = params.sessionId;
-      if (typeof sessionId === "string") {
-        const targetId = state.attachedTargets.get(sessionId);
-        if (targetId) {
-          state.sessions.delete(targetId);
-          state.attachedTargets.delete(sessionId);
-          state.activeFrameIdByTarget.delete(targetId);
-          state.dialogHandlers.delete(targetId);
-          if (state.currentTargetId === targetId) {
-            state.currentTargetId = void 0;
-            persistCurrentTargetId(state.host, state.port, void 0);
-          }
-        }
-      }
-      return;
-    }
-    if (message.method === "Target.receivedMessageFromTarget") {
-      const params = message.params;
-      const sessionId = params.sessionId;
-      const messageText = params.message;
-      if (typeof sessionId === "string" && typeof messageText === "string") {
-        const targetId = state.attachedTargets.get(sessionId);
-        if (targetId) {
-          handleSessionEvent(targetId, JSON.parse(messageText)).catch(() => {
-          });
-        }
-      }
-      return;
-    }
-    if (typeof message.sessionId === "string" && typeof message.method === "string") {
-      const targetId = state.attachedTargets.get(message.sessionId);
-      if (targetId) {
-        handleSessionEvent(targetId, message).catch(() => {
-        });
-      }
-    }
-  });
-  browserSocket.on("close", () => {
-    if (connectionState === state) {
-      connectionState = null;
-    }
-    for (const pending of state.browserPending.values()) {
-      pending.reject(new Error("CDP connection closed"));
-    }
-    state.browserPending.clear();
-  });
-  browserSocket.on("error", () => {
-  });
-  return state;
-}
-async function browserCommand(method, params = {}) {
-  const state = connectionState;
-  if (!state) throw new Error("CDP connection not initialized");
-  const id = state.nextMessageId++;
-  const payload = JSON.stringify({ id, method, params });
-  const promise = new Promise((resolve3, reject) => {
-    state.browserPending.set(id, { resolve: resolve3, reject, method });
-  });
-  state.browserSocket.send(payload);
-  return promise;
-}
-async function sessionCommand(targetId, method, params = {}) {
-  const state = connectionState;
-  if (!state) throw new Error("CDP connection not initialized");
-  const sessionId = state.sessions.get(targetId) ?? await attachTarget(targetId);
-  const id = state.nextMessageId++;
-  const payload = JSON.stringify({ id, method, params, sessionId });
-  return new Promise((resolve3, reject) => {
-    const check = (raw) => {
-      const msg = JSON.parse(raw.toString());
-      if (msg.id === id && msg.sessionId === sessionId) {
-        state.browserSocket.off("message", check);
-        if (msg.error) reject(new Error(`${method}: ${msg.error.message ?? "Unknown CDP error"}`));
-        else resolve3(msg.result);
-      }
-    };
-    state.browserSocket.on("message", check);
-    state.browserSocket.send(payload);
-  });
-}
-function getActiveFrameId(targetId) {
-  const frameId = connectionState?.activeFrameIdByTarget.get(targetId);
-  return frameId ?? void 0;
-}
-async function pageCommand(targetId, method, params = {}) {
-  const frameId = getActiveFrameId(targetId);
-  return sessionCommand(targetId, method, frameId ? { ...params, frameId } : params);
-}
-function normalizeHeaders(headers) {
-  if (!headers || typeof headers !== "object") return void 0;
-  return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, String(value)]));
-}
-async function handleSessionEvent(targetId, event) {
-  const method = event.method;
-  const params = event.params ?? {};
-  if (typeof method !== "string") return;
-  if (method === "Page.javascriptDialogOpening") {
-    const handler = connectionState?.dialogHandlers.get(targetId);
-    if (handler) {
-      await sessionCommand(targetId, "Page.handleJavaScriptDialog", {
-        accept: handler.accept,
-        ...handler.promptText !== void 0 ? { promptText: handler.promptText } : {}
-      });
-    }
-    return;
-  }
-  if (method === "Network.requestWillBeSent") {
-    const requestId = typeof params.requestId === "string" ? params.requestId : void 0;
-    const request = params.request;
-    if (!requestId || !request) return;
-    networkRequests.set(requestId, {
-      requestId,
-      url: String(request.url ?? ""),
-      method: String(request.method ?? "GET"),
-      type: String(params.type ?? "Other"),
-      timestamp: Math.round(Number(params.timestamp ?? Date.now()) * 1e3),
-      requestHeaders: normalizeHeaders(request.headers),
-      requestBody: typeof request.postData === "string" ? request.postData : void 0
-    });
-    return;
-  }
-  if (method === "Network.responseReceived") {
-    const requestId = typeof params.requestId === "string" ? params.requestId : void 0;
-    const response = params.response;
-    if (!requestId || !response) return;
-    const existing = networkRequests.get(requestId);
-    if (!existing) return;
-    existing.status = typeof response.status === "number" ? response.status : void 0;
-    existing.statusText = typeof response.statusText === "string" ? response.statusText : void 0;
-    existing.responseHeaders = normalizeHeaders(response.headers);
-    existing.mimeType = typeof response.mimeType === "string" ? response.mimeType : void 0;
-    networkRequests.set(requestId, existing);
-    return;
-  }
-  if (method === "Network.loadingFailed") {
-    const requestId = typeof params.requestId === "string" ? params.requestId : void 0;
-    if (!requestId) return;
-    const existing = networkRequests.get(requestId);
-    if (!existing) return;
-    existing.failed = true;
-    existing.failureReason = typeof params.errorText === "string" ? params.errorText : "Unknown error";
-    networkRequests.set(requestId, existing);
-    return;
-  }
-  if (method === "Runtime.consoleAPICalled") {
-    const type = String(params.type ?? "log");
-    const args = Array.isArray(params.args) ? params.args : [];
-    const text = args.map((arg) => {
-      if (typeof arg.value === "string") return arg.value;
-      if (arg.value !== void 0) return String(arg.value);
-      if (typeof arg.description === "string") return arg.description;
-      return "";
-    }).filter(Boolean).join(" ");
-    const stack = params.stackTrace;
-    const firstCallFrame = Array.isArray(stack?.callFrames) ? stack?.callFrames[0] : void 0;
-    consoleMessages.push({
-      type: ["log", "info", "warn", "error", "debug"].includes(type) ? type : "log",
-      text,
-      timestamp: Math.round(Number(params.timestamp ?? Date.now())),
-      url: typeof firstCallFrame?.url === "string" ? firstCallFrame.url : void 0,
-      lineNumber: typeof firstCallFrame?.lineNumber === "number" ? firstCallFrame.lineNumber : void 0
-    });
-    return;
-  }
-  if (method === "Runtime.exceptionThrown") {
-    const details = params.exceptionDetails;
-    if (!details) return;
-    const exception = details.exception;
-    const stackTrace = details.stackTrace;
-    const callFrames = Array.isArray(stackTrace?.callFrames) ? stackTrace.callFrames : [];
-    jsErrors.push({
-      message: typeof exception?.description === "string" ? exception.description : String(details.text ?? "JavaScript exception"),
-      url: typeof details.url === "string" ? details.url : typeof callFrames[0]?.url === "string" ? String(callFrames[0].url) : void 0,
-      lineNumber: typeof details.lineNumber === "number" ? details.lineNumber : void 0,
-      columnNumber: typeof details.columnNumber === "number" ? details.columnNumber : void 0,
-      stackTrace: callFrames.length > 0 ? callFrames.map((frame) => `${String(frame.functionName ?? "<anonymous>")} (${String(frame.url ?? "")}:${String(frame.lineNumber ?? 0)}:${String(frame.columnNumber ?? 0)})`).join("\n") : void 0,
-      timestamp: Date.now()
-    });
-  }
-}
-async function ensureNetworkMonitoring(targetId) {
-  if (networkEnabled) return;
-  await sessionCommand(targetId, "Network.enable");
-  networkEnabled = true;
-}
-async function ensureConsoleMonitoring(targetId) {
-  if (consoleEnabled && errorsEnabled) return;
-  await sessionCommand(targetId, "Runtime.enable");
-  consoleEnabled = true;
-  errorsEnabled = true;
-}
-async function attachTarget(targetId) {
-  const result = await browserCommand("Target.attachToTarget", {
-    targetId,
-    flatten: true
-  });
-  connectionState?.sessions.set(targetId, result.sessionId);
-  connectionState?.attachedTargets.set(result.sessionId, targetId);
-  connectionState?.activeFrameIdByTarget.set(targetId, connectionState?.activeFrameIdByTarget.get(targetId) ?? null);
-  await sessionCommand(targetId, "Page.enable");
-  await sessionCommand(targetId, "Runtime.enable");
-  await sessionCommand(targetId, "DOM.enable");
-  await sessionCommand(targetId, "Accessibility.enable");
-  return result.sessionId;
-}
-async function getTargets() {
-  const state = connectionState;
-  if (!state) throw new Error("CDP connection not initialized");
-  try {
-    const result = await browserCommand("Target.getTargets");
-    return (result.targetInfos || []).map((target) => ({
-      id: target.targetId,
-      type: target.type,
-      title: target.title,
-      url: target.url,
-      webSocketDebuggerUrl: ""
-    }));
-  } catch {
-    return getJsonList(state.host, state.port);
-  }
-}
-async function ensurePageTarget(targetId) {
-  const targets = (await getTargets()).filter((target2) => target2.type === "page");
-  if (targets.length === 0) throw new Error("No page target found");
-  const persistedTargetId = targetId === void 0 ? connectionState?.currentTargetId : void 0;
-  let target;
-  if (typeof targetId === "number") {
-    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);
-      }
-    }
-  } else if (persistedTargetId) {
-    target = targets.find((item) => item.id === persistedTargetId);
-  }
-  target ??= targets[0];
-  setCurrentTargetId(target.id);
-  await attachTarget(target.id);
-  return target;
-}
-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) {
-    throw new Error(`Unknown ref: ${ref}. Run snapshot first.`);
-  }
-  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) {
+// packages/cli/src/daemon-manager.ts
+var DAEMON_DIR = process.env.BB_BROWSER_HOME || path2.join(os2.homedir(), ".bb-browser");
+var DAEMON_JSON = path2.join(DAEMON_DIR, "daemon.json");
+var cachedInfo = null;
+var daemonReady = false;
+function isProcessAlive(pid) {
   try {
-    unlinkSync(getRefsFilePath(targetId));
+    process.kill(pid, 0);
+    return true;
   } catch {
+    return false;
   }
 }
-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/dist/buildDomTree.js"),
-    path2.resolve(currentDir, "../../../packages/extension/public/buildDomTree.js")
-  ];
-  for (const candidate of candidates) {
-    try {
-      return readFileSync(candidate, "utf8");
-    } catch {
-    }
-  }
-  throw new Error("Cannot find buildDomTree.js");
-}
-async function evaluate(targetId, expression, returnByValue = true) {
-  const result = await sessionCommand(targetId, "Runtime.evaluate", {
-    expression,
-    awaitPromise: true,
-    returnByValue
-  });
-  if (result.exceptionDetails) {
-    throw new Error(
-      result.exceptionDetails.exception?.description || result.exceptionDetails.text || "Runtime.evaluate failed"
-    );
-  }
-  return result.result.value ?? result.result;
-}
-async function focusNode(targetId, backendNodeId) {
-  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(clearFirst) {
-      if (typeof this.scrollIntoView === 'function') {
-        this.scrollIntoView({ behavior: 'auto', block: 'center', inline: 'center' });
-      }
-      if (typeof this.focus === 'function') this.focus();
-      if (this instanceof HTMLInputElement || this instanceof HTMLTextAreaElement) {
-        if (clearFirst) {
-          this.value = '';
-          this.dispatchEvent(new Event('input', { bubbles: true }));
-        }
-        if (typeof this.setSelectionRange === 'function') {
-          const end = this.value.length;
-          this.setSelectionRange(end, end);
-        }
-        return true;
-      }
-      if (this instanceof HTMLElement && this.isContentEditable) {
-        if (clearFirst) {
-          this.textContent = '';
-          this.dispatchEvent(new Event('input', { bubbles: true }));
-        }
-        const selection = window.getSelection();
-        if (selection) {
-          const range = document.createRange();
-          range.selectNodeContents(this);
-          range.collapse(false);
-          selection.removeAllRanges();
-          selection.addRange(range);
-        }
-        return true;
-      }
-      return false;
-    }`,
-    arguments: [
-      { value: clearFirst }
-    ],
-    returnByValue: true
-  });
-  if (text) {
-    await focusNode(targetId, backendNodeId);
-    await sessionCommand(targetId, "Input.insertText", { text });
-  }
-}
-async function getInteractablePoint(targetId, backendNodeId) {
-  const resolved = await sessionCommand(targetId, "DOM.resolveNode", { backendNodeId });
-  const call = await sessionCommand(targetId, "Runtime.callFunctionOn", {
-    objectId: resolved.object.objectId,
-    functionDeclaration: `function() {
-      if (!(this instanceof Element)) {
-        throw new Error('Ref does not resolve to an element');
-      }
-      this.scrollIntoView({ behavior: 'auto', block: 'center', inline: 'center' });
-      const rect = this.getBoundingClientRect();
-      if (!rect || rect.width <= 0 || rect.height <= 0) {
-        throw new Error('Element is not visible');
-      }
-      return {
-        x: rect.left + rect.width / 2,
-        y: rect.top + rect.height / 2,
-      };
-    }`,
-    returnByValue: true
-  });
-  if (call.exceptionDetails) {
-    throw new Error(call.exceptionDetails.text || "Failed to resolve element point");
-  }
-  const point = call.result.value;
-  if (!point || typeof point.x !== "number" || typeof point.y !== "number" || !Number.isFinite(point.x) || !Number.isFinite(point.y)) {
-    throw new Error("Failed to resolve element point");
-  }
-  return point;
-}
-async function mouseClick(targetId, x, y) {
-  await sessionCommand(targetId, "Input.dispatchMouseEvent", { type: "mouseMoved", x, y, button: "none" });
-  await sessionCommand(targetId, "Input.dispatchMouseEvent", { type: "mousePressed", x, y, button: "left", clickCount: 1 });
-  await sessionCommand(targetId, "Input.dispatchMouseEvent", { type: "mouseReleased", x, y, button: "left", clickCount: 1 });
-}
-async function getAttributeValue(targetId, backendNodeId, attribute) {
-  if (attribute === "text") {
-    const resolved = await sessionCommand(targetId, "DOM.resolveNode", { backendNodeId });
-    const call2 = await sessionCommand(targetId, "Runtime.callFunctionOn", {
-      objectId: resolved.object.objectId,
-      functionDeclaration: `function() { return (this instanceof HTMLElement ? this.innerText : this.textContent || '').trim(); }`,
-      returnByValue: true
-    });
-    return String(call2.result.value ?? "");
-  }
-  const result = await sessionCommand(targetId, "DOM.resolveNode", { backendNodeId });
-  const call = await sessionCommand(targetId, "Runtime.callFunctionOn", {
-    objectId: result.object.objectId,
-    functionDeclaration: `function() { if (${JSON.stringify(attribute)} === 'url') return this.href || this.src || location.href; if (${JSON.stringify(attribute)} === 'title') return document.title; return this.getAttribute(${JSON.stringify(attribute)}) || ''; }`,
-    returnByValue: true
-  });
-  return String(call.result.value ?? "");
-}
-async function buildSnapshot(targetId, request) {
-  const script = loadBuildDomTreeScript();
-  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 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 };
-}
-function fail(id, error) {
-  return { id, success: false, error: buildRequestError(error).message };
-}
-async function ensureCdpConnection() {
-  if (connectionState) return;
-  if (reconnecting) return reconnecting;
-  reconnecting = (async () => {
-    const discovered = await discoverCdpPort();
-    if (!discovered) {
-      throw new Error("No browser connection found");
-    }
-    const version = await getJsonVersion(discovered.host, discovered.port);
-    const wsUrl = version.webSocketDebuggerUrl;
-    const socket = await connectWebSocket(wsUrl);
-    connectionState = createState(discovered.host, discovered.port, wsUrl, socket);
-  })();
-  try {
-    await reconnecting;
-  } finally {
-    reconnecting = null;
-  }
-}
-async function sendCommand(request) {
-  try {
-    await ensureCdpConnection();
-    const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("\u8BF7\u6C42\u8D85\u65F6")), COMMAND_TIMEOUT));
-    return await Promise.race([dispatchRequest(request), timeout]);
-  } catch (error) {
-    return fail(request.id, error);
-  }
-}
-async function dispatchRequest(request) {
-  const target = await ensurePageTarget(request.tabId);
-  switch (request.action) {
-    case "open": {
-      if (!request.url) return fail(request.id, "Missing url parameter");
-      if (request.tabId === void 0) {
-        const created = await browserCommand("Target.createTarget", { url: request.url, background: true });
-        const newTarget = await ensurePageTarget(created.targetId);
-        return ok(request.id, { url: request.url, tabId: newTarget.id });
-      }
-      await pageCommand(target.id, "Page.navigate", { url: request.url });
-      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);
-      return ok(request.id, { title: target.title, url: target.url, snapshotData });
-    }
-    case "click":
-    case "hover": {
-      if (!request.ref) return fail(request.id, "Missing ref parameter");
-      const backendNodeId = await parseRef(request.ref);
-      const point = await getInteractablePoint(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);
-      return ok(request.id, {});
-    }
-    case "fill":
-    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 = 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 = await parseRef(request.ref);
-      const desired = request.action === "check";
-      const resolved = await sessionCommand(target.id, "DOM.resolveNode", { backendNodeId });
-      await sessionCommand(target.id, "Runtime.callFunctionOn", {
-        objectId: resolved.object.objectId,
-        functionDeclaration: `function() { this.checked = ${desired}; this.dispatchEvent(new Event('input', { bubbles: true })); this.dispatchEvent(new Event('change', { bubbles: true })); }`
-      });
-      return ok(request.id, {});
-    }
-    case "select": {
-      if (!request.ref || request.value == null) return fail(request.id, "Missing ref or value parameter");
-      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,
-        functionDeclaration: `function() { this.value = ${JSON.stringify(request.value)}; this.dispatchEvent(new Event('input', { bubbles: true })); this.dispatchEvent(new Event('change', { bubbles: true })); }`
-      });
-      return ok(request.id, { value: request.value });
-    }
-    case "get": {
-      if (!request.attribute) return fail(request.id, "Missing attribute parameter");
-      if (request.attribute === "url" && !request.ref) {
-        return ok(request.id, { value: await evaluate(target.id, "location.href", true) });
-      }
-      if (request.attribute === "title" && !request.ref) {
-        return ok(request.id, { value: await evaluate(target.id, "document.title", true) });
-      }
-      if (!request.ref) return fail(request.id, "Missing ref parameter");
-      const value = await getAttributeValue(target.id, await parseRef(request.ref), request.attribute);
-      return ok(request.id, { value });
-    }
-    case "screenshot": {
-      const result = await sessionCommand(target.id, "Page.captureScreenshot", { format: "png", fromSurface: true });
-      return ok(request.id, { dataUrl: `data:image/png;base64,${result.data}` });
-    }
-    case "close": {
-      await browserCommand("Target.closeTarget", { targetId: target.id });
-      connectionState?.refsByTarget.delete(target.id);
-      clearPersistedRefs(target.id);
-      return ok(request.id, {});
-    }
-    case "wait": {
-      await new Promise((resolve3) => setTimeout(resolve3, request.ms ?? 1e3));
-      return ok(request.id, {});
-    }
-    case "press": {
-      if (!request.key) return fail(request.id, "Missing key parameter");
-      await sessionCommand(target.id, "Input.dispatchKeyEvent", { type: "keyDown", key: request.key });
-      if (request.key.length === 1) {
-        await sessionCommand(target.id, "Input.dispatchKeyEvent", { type: "char", text: request.key, key: request.key });
-      }
-      await sessionCommand(target.id, "Input.dispatchKeyEvent", { type: "keyUp", key: request.key });
-      return ok(request.id, {});
-    }
-    case "scroll": {
-      const deltaY = request.direction === "up" ? -(request.pixels ?? 300) : request.pixels ?? 300;
-      await sessionCommand(target.id, "Input.dispatchMouseEvent", { type: "mouseWheel", x: 0, y: 0, deltaX: 0, deltaY });
-      return ok(request.id, {});
-    }
-    case "back": {
-      await evaluate(target.id, "history.back(); undefined");
-      return ok(request.id, {});
-    }
-    case "forward": {
-      await evaluate(target.id, "history.forward(); undefined");
-      return ok(request.id, {});
-    }
-    case "refresh": {
-      await sessionCommand(target.id, "Page.reload", { ignoreCache: false });
-      return ok(request.id, {});
-    }
-    case "eval": {
-      if (!request.script) return fail(request.id, "Missing script parameter");
-      const result = await evaluate(target.id, request.script, true);
-      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: 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", background: true });
-      return ok(request.id, { tabId: created.targetId, url: request.url ?? "about:blank" });
-    }
-    case "tab_select": {
-      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");
-      setCurrentTargetId(selected.id);
-      await attachTarget(selected.id);
-      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 });
-      connectionState?.refsByTarget.delete(selected.id);
-      if (connectionState?.currentTargetId === selected.id) {
-        setCurrentTargetId(void 0);
-      }
-      clearPersistedRefs(selected.id);
-      return ok(request.id, { tabId: selected.id });
-    }
-    case "frame": {
-      if (!request.selector) return fail(request.id, "Missing selector parameter");
-      const document = await pageCommand(target.id, "DOM.getDocument", {});
-      const node = await pageCommand(target.id, "DOM.querySelector", { nodeId: document.root.nodeId, selector: request.selector });
-      if (!node.nodeId) return fail(request.id, `\u627E\u4E0D\u5230 iframe: ${request.selector}`);
-      const described = await pageCommand(target.id, "DOM.describeNode", { nodeId: node.nodeId });
-      const frameId = described.node.frameId;
-      const nodeName = String(described.node.nodeName ?? "").toLowerCase();
-      if (!frameId) return fail(request.id, `\u65E0\u6CD5\u83B7\u53D6 iframe frameId: ${request.selector}`);
-      if (nodeName && nodeName !== "iframe" && nodeName !== "frame") return fail(request.id, `\u5143\u7D20\u4E0D\u662F iframe: ${nodeName}`);
-      connectionState?.activeFrameIdByTarget.set(target.id, frameId);
-      const attributes = described.node.attributes ?? [];
-      const attrMap = {};
-      for (let i = 0; i < attributes.length; i += 2) attrMap[String(attributes[i])] = String(attributes[i + 1] ?? "");
-      return ok(request.id, { frameInfo: { selector: request.selector, name: attrMap.name ?? "", url: attrMap.src ?? "", frameId } });
-    }
-    case "frame_main": {
-      connectionState?.activeFrameIdByTarget.set(target.id, null);
-      return ok(request.id, { frameInfo: { frameId: 0 } });
-    }
-    case "dialog": {
-      connectionState?.dialogHandlers.set(target.id, { accept: request.dialogResponse !== "dismiss", ...request.promptText !== void 0 ? { promptText: request.promptText } : {} });
-      await sessionCommand(target.id, "Page.enable");
-      return ok(request.id, { dialog: { armed: true, response: request.dialogResponse ?? "accept" } });
-    }
-    case "network": {
-      const subCommand = request.networkCommand ?? "requests";
-      switch (subCommand) {
-        case "requests": {
-          await ensureNetworkMonitoring(target.id);
-          const requests = Array.from(networkRequests.values()).filter((item) => !request.filter || item.url.includes(request.filter));
-          if (request.withBody) {
-            await Promise.all(requests.map(async (item) => {
-              if (item.failed || item.responseBody !== void 0 || item.bodyError !== void 0) return;
-              try {
-                const body = await sessionCommand(target.id, "Network.getResponseBody", { requestId: item.requestId });
-                item.responseBody = body.body;
-                item.responseBodyBase64 = body.base64Encoded;
-              } catch (error) {
-                item.bodyError = error instanceof Error ? error.message : String(error);
-              }
-            }));
-          }
-          return ok(request.id, { networkRequests: requests });
-        }
-        case "route":
-          return ok(request.id, { routeCount: 0 });
-        case "unroute":
-          return ok(request.id, { routeCount: 0 });
-        case "clear":
-          networkRequests.clear();
-          return ok(request.id, {});
-        default:
-          return fail(request.id, `Unknown network subcommand: ${subCommand}`);
-      }
-    }
-    case "console": {
-      const subCommand = request.consoleCommand ?? "get";
-      await ensureConsoleMonitoring(target.id);
-      switch (subCommand) {
-        case "get":
-          return ok(request.id, { consoleMessages: consoleMessages.filter((item) => !request.filter || item.text.includes(request.filter)) });
-        case "clear":
-          consoleMessages.length = 0;
-          return ok(request.id, {});
-        default:
-          return fail(request.id, `Unknown console subcommand: ${subCommand}`);
-      }
-    }
-    case "errors": {
-      const subCommand = request.errorsCommand ?? "get";
-      await ensureConsoleMonitoring(target.id);
-      switch (subCommand) {
-        case "get":
-          return ok(request.id, { jsErrors: jsErrors.filter((item) => !request.filter || item.message.includes(request.filter) || item.url?.includes(request.filter)) });
-        case "clear":
-          jsErrors.length = 0;
-          return ok(request.id, {});
-        default:
-          return fail(request.id, `Unknown errors subcommand: ${subCommand}`);
-      }
-    }
-    case "trace": {
-      const subCommand = request.traceCommand ?? "status";
-      switch (subCommand) {
-        case "start":
-          traceRecording = true;
-          traceEvents.length = 0;
-          return ok(request.id, { traceStatus: { recording: true, eventCount: 0 } });
-        case "stop": {
-          traceRecording = false;
-          return ok(request.id, { traceEvents: [...traceEvents], traceStatus: { recording: false, eventCount: traceEvents.length } });
-        }
-        case "status":
-          return ok(request.id, { traceStatus: { recording: traceRecording, eventCount: traceEvents.length } });
-        default:
-          return fail(request.id, `Unknown trace subcommand: ${subCommand}`);
-      }
-    }
-    default:
-      return fail(request.id, `Action not yet supported in direct CDP mode: ${request.action}`);
-  }
-}
-
-// packages/cli/src/monitor-manager.ts
-import { spawn as spawn2 } from "child_process";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2, unlink } from "fs/promises";
-import { request as httpRequest2 } from "http";
-import { randomBytes } from "crypto";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname, resolve } from "path";
-import { existsSync as existsSync2 } from "fs";
-import os3 from "os";
-import path3 from "path";
-var MONITOR_DIR = path3.join(os3.homedir(), ".bb-browser");
-var PID_FILE = path3.join(MONITOR_DIR, "monitor.pid");
-var PORT_FILE = path3.join(MONITOR_DIR, "monitor.port");
-var TOKEN_FILE = path3.join(MONITOR_DIR, "monitor.token");
-var DEFAULT_MONITOR_PORT = 19826;
-function httpJson(method, url, token, body) {
-  return new Promise((resolve3, reject) => {
-    const parsed = new URL(url);
+function httpJson(method, urlPath, info, body, timeout = 5e3) {
+  return new Promise((resolve2, reject) => {
     const payload = body !== void 0 ? JSON.stringify(body) : void 0;
-    const req = httpRequest2(
+    const req = httpRequest(
       {
-        hostname: parsed.hostname,
-        port: parsed.port,
-        path: parsed.pathname,
+        hostname: info.host,
+        port: info.port,
+        path: urlPath,
         method,
         headers: {
-          Authorization: `Bearer ${token}`,
-          ...payload ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) } : {}
+          Authorization: `Bearer ${info.token}`,
+          ...payload ? {
+            "Content-Type": "application/json",
+            "Content-Length": Buffer.byteLength(payload)
+          } : {}
         },
-        timeout: 5e3
+        timeout
       },
       (res) => {
         const chunks = [];
@@ -1304,13 +282,13 @@ function httpJson(method, url, token, body) {
         res.on("end", () => {
           const raw = Buffer.concat(chunks).toString("utf8");
           if ((res.statusCode ?? 500) >= 400) {
-            reject(new Error(`Monitor HTTP ${res.statusCode}: ${raw}`));
+            reject(new Error(`Daemon HTTP ${res.statusCode}: ${raw}`));
             return;
           }
           try {
-            resolve3(JSON.parse(raw));
+            resolve2(JSON.parse(raw));
           } catch {
-            reject(new Error(`Invalid JSON from monitor: ${raw}`));
+            reject(new Error(`Invalid JSON from daemon: ${raw}`));
           }
         });
       }
@@ -1318,116 +296,130 @@ function httpJson(method, url, token, body) {
     req.on("error", reject);
     req.on("timeout", () => {
       req.destroy();
-      reject(new Error("Monitor request timed out"));
+      reject(new Error("Daemon request timed out"));
     });
     if (payload) req.write(payload);
     req.end();
   });
 }
-async function readPortFile() {
+async function readDaemonJson() {
   try {
-    const raw = await readFile2(PORT_FILE, "utf8");
-    const port = Number.parseInt(raw.trim(), 10);
-    return Number.isInteger(port) && port > 0 ? port : null;
+    const raw = await readFile2(DAEMON_JSON, "utf8");
+    const info = JSON.parse(raw);
+    if (typeof info.pid === "number" && typeof info.host === "string" && typeof info.port === "number" && typeof info.token === "string") {
+      return info;
+    }
+    return null;
   } catch {
     return null;
   }
 }
-async function readTokenFile() {
+async function deleteDaemonJson() {
   try {
-    return (await readFile2(TOKEN_FILE, "utf8")).trim();
+    await unlink(DAEMON_JSON);
   } catch {
-    return null;
   }
 }
-async function ensureMonitorRunning() {
-  const existingPort = await readPortFile();
-  const existingToken = await readTokenFile();
-  if (existingPort && existingToken) {
+function getDaemonPath() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const currentDir = dirname(currentFile);
+  const sameDirPath = resolve(currentDir, "daemon.js");
+  if (existsSync2(sameDirPath)) {
+    return sameDirPath;
+  }
+  return resolve(currentDir, "../../daemon/dist/index.js");
+}
+async function ensureDaemon() {
+  if (daemonReady && cachedInfo) {
     try {
-      const status = await httpJson(
-        "GET",
-        `http://127.0.0.1:${existingPort}/status`,
-        existingToken
-      );
-      if (status.running) {
-        return { port: existingPort, token: existingToken };
-      }
+      await httpJson("GET", "/status", cachedInfo, void 0, 2e3);
+      return;
     } catch {
+      daemonReady = false;
+      cachedInfo = null;
     }
   }
-  const cdp = await discoverCdpPort();
-  if (!cdp) {
-    throw new Error("Cannot start monitor: no browser connection found");
-  }
-  const token = randomBytes(32).toString("hex");
-  const monitorPort = DEFAULT_MONITOR_PORT;
-  const monitorScript = findMonitorScript();
-  await mkdir2(MONITOR_DIR, { recursive: true });
-  await writeFile2(TOKEN_FILE, token, { mode: 384 });
-  const child = spawn2(process.execPath, [
-    monitorScript,
-    "--cdp-host",
-    cdp.host,
-    "--cdp-port",
-    String(cdp.port),
-    "--monitor-port",
-    String(monitorPort),
-    "--token",
-    token
-  ], {
+  let info = await readDaemonJson();
+  if (info) {
+    if (!isProcessAlive(info.pid)) {
+      await deleteDaemonJson();
+      info = null;
+    } else {
+      try {
+        const status = await httpJson("GET", "/status", info, void 0, 2e3);
+        if (status.running) {
+          cachedInfo = info;
+          daemonReady = true;
+          return;
+        }
+      } catch {
+      }
+    }
+  }
+  const cdpInfo = await discoverCdpPort();
+  if (!cdpInfo) {
+    throw new Error(
+      "bb-browser: Cannot find a Chromium-based browser.\n\nPlease do one of the following:\n  1. Install Google Chrome, Edge, or Brave\n  2. Start Chrome with: google-chrome --remote-debugging-port=19825\n  3. Set BB_BROWSER_CDP_URL=http://host:port"
+    );
+  }
+  const daemonPath = getDaemonPath();
+  const child = spawn2(process.execPath, [daemonPath, "--cdp-host", cdpInfo.host, "--cdp-port", String(cdpInfo.port)], {
     detached: true,
     stdio: "ignore"
   });
   child.unref();
-  const deadline = Date.now() + 5e3;
+  const deadline = Date.now() + 1e4;
   while (Date.now() < deadline) {
     await new Promise((r) => setTimeout(r, 200));
+    info = await readDaemonJson();
+    if (!info) continue;
     try {
-      const status = await httpJson(
-        "GET",
-        `http://127.0.0.1:${monitorPort}/status`,
-        token
-      );
+      const status = await httpJson("GET", "/status", info, void 0, 2e3);
       if (status.running) {
-        return { port: monitorPort, token };
+        cachedInfo = info;
+        daemonReady = true;
+        return;
       }
     } catch {
     }
   }
-  throw new Error("Monitor process did not start in time");
-}
-async function monitorCommand(request) {
-  const { port, token } = await ensureMonitorRunning();
-  return httpJson(
-    "POST",
-    `http://127.0.0.1:${port}/command`,
-    token,
-    request
+  throw new Error(
+    "bb-browser: Daemon did not start in time.\n\nChrome CDP is reachable, but the daemon process failed to initialize.\nTry: bb-browser daemon status"
   );
 }
-function findMonitorScript() {
-  const currentFile = fileURLToPath2(import.meta.url);
-  const currentDir = dirname(currentFile);
-  const candidates = [
-    // Built output (tsup puts it next to cli.js)
-    resolve(currentDir, "cdp-monitor.js"),
-    // Development: packages/cli/src -> packages/cli/dist
-    resolve(currentDir, "../dist/cdp-monitor.js"),
-    // Monorepo root dist
-    resolve(currentDir, "../../dist/cdp-monitor.js"),
-    resolve(currentDir, "../../../dist/cdp-monitor.js")
-  ];
-  for (const candidate of candidates) {
-    if (existsSync2(candidate)) {
-      return candidate;
-    }
+async function daemonCommand(request) {
+  if (!cachedInfo) {
+    cachedInfo = await readDaemonJson();
+  }
+  if (!cachedInfo) {
+    throw new Error("No daemon.json found. Is the daemon running?");
+  }
+  return httpJson("POST", "/command", cachedInfo, request, COMMAND_TIMEOUT);
+}
+async function stopDaemon() {
+  const info = cachedInfo ?? await readDaemonJson();
+  if (!info) return false;
+  try {
+    await httpJson("POST", "/shutdown", info);
+    daemonReady = false;
+    cachedInfo = null;
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getDaemonStatus() {
+  const info = cachedInfo ?? await readDaemonJson();
+  if (!info) return null;
+  try {
+    return await httpJson("GET", "/status", info, void 0, 2e3);
+  } catch {
+    return null;
   }
-  return candidates[0];
 }
+var ensureDaemonRunning = ensureDaemon;
 
 // packages/cli/src/client.ts
-var MONITOR_ACTIONS = /* @__PURE__ */ new Set(["network", "console", "errors", "trace"]);
 var jqExpression;
 function setJqExpression(expression) {
   jqExpression = expression;
@@ -1445,42 +437,13 @@ function handleJqResponse(response) {
     printJqResults(response);
   }
 }
-async function sendCommand2(request) {
-  if (MONITOR_ACTIONS.has(request.action)) {
-    try {
-      return await monitorCommand(request);
-    } catch {
-      return sendCommand(request);
-    }
-  }
-  return sendCommand(request);
-}
-
-// packages/cli/src/daemon-manager.ts
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname2, resolve as resolve2 } from "path";
-import { existsSync as existsSync3 } from "fs";
-async function isDaemonRunning() {
-  return await isManagedBrowserRunning();
-}
-async function ensureDaemonRunning() {
-  try {
-    await ensureCdpConnection();
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("No browser connection found")) {
-      throw new Error([
-        "bb-browser: Could not start browser.",
-        "",
-        "Make sure Chrome is installed, then try again.",
-        "Or specify a CDP port manually: bb-browser --port 9222"
-      ].join("\n"));
-    }
-    throw error;
-  }
+async function sendCommand(request) {
+  await ensureDaemon();
+  return daemonCommand(request);
 }
 
 // packages/cli/src/history-sqlite.ts
-import { copyFileSync, existsSync as existsSync4, unlinkSync as unlinkSync2 } from "fs";
+import { copyFileSync, existsSync as existsSync3, unlinkSync } from "fs";
 import { execSync as execSync2 } from "child_process";
 import { homedir, tmpdir } from "os";
 import { join } from "path";
@@ -1504,7 +467,7 @@ function getHistoryPathCandidates() {
 }
 function findHistoryPath() {
   for (const historyPath of getHistoryPathCandidates()) {
-    if (existsSync4(historyPath)) {
+    if (existsSync3(historyPath)) {
       return historyPath;
     }
   }
@@ -1538,7 +501,7 @@ function runHistoryQuery(sql, mapRow) {
     return [];
   } finally {
     try {
-      unlinkSync2(tmpPath);
+      unlinkSync(tmpPath);
     } catch {
     }
   }
@@ -1624,7 +587,7 @@ function getHistoryDomains(days) {
 }
 
 // packages/cli/src/commands/site.ts
-import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync5, mkdirSync } from "fs";
+import { readFileSync, readdirSync, existsSync as existsSync4, mkdirSync } from "fs";
 import { join as join2, relative } from "path";
 import { homedir as homedir2 } from "os";
 import { execSync as execSync3 } from "child_process";
@@ -1650,7 +613,7 @@ function exitJsonError(error, extra = {}) {
 function parseSiteMeta(filePath, source) {
   let content;
   try {
-    content = readFileSync2(filePath, "utf-8");
+    content = readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -1710,7 +673,7 @@ function parseSiteMeta(filePath, source) {
   return meta;
 }
 function scanSites(dir, source) {
-  if (!existsSync5(dir)) return [];
+  if (!existsSync4(dir)) return [];
   const sites = [];
   function walk(currentDir) {
     let entries;
@@ -1832,7 +795,7 @@ function siteSearch(query, options) {
 }
 function siteUpdate(options = {}) {
   mkdirSync(BB_DIR, { recursive: true });
-  const updateMode = existsSync5(join2(COMMUNITY_SITES_DIR, ".git")) ? "pull" : "clone";
+  const updateMode = existsSync4(join2(COMMUNITY_SITES_DIR, ".git")) ? "pull" : "clone";
   if (updateMode === "pull") {
     if (!options.json) {
       console.log("\u66F4\u65B0\u793E\u533A site adapter \u5E93...");
@@ -2068,12 +1031,12 @@ async function siteRun(name, args, options) {
       process.exit(1);
     }
   }
-  const jsContent = readFileSync2(site.filePath, "utf-8");
+  const jsContent = readFileSync(site.filePath, "utf-8");
   const jsBody = jsContent.replace(/\/\*\s*@meta[\s\S]*?\*\//, "").trim();
   const argsJson = JSON.stringify(argMap);
   const script = `(${jsBody})(${argsJson})`;
   if (options.openclaw) {
-    const { ocGetTabs, ocFindTabByDomain, ocOpenTab, ocEvaluate } = await import("./openclaw-bridge-7BW5M4YX.js");
+    const { ocGetTabs, ocFindTabByDomain, ocOpenTab, ocEvaluate } = await import("./openclaw-bridge-4XJKWEQ3.js");
     let targetId;
     if (site.domain) {
       const tabs = ocGetTabs();
@@ -2082,7 +1045,7 @@ async function siteRun(name, args, options) {
         targetId = existing.targetId;
       } else {
         targetId = ocOpenTab(`https://${site.domain}`);
-        await new Promise((resolve3) => setTimeout(resolve3, 3e3));
+        await new Promise((resolve2) => setTimeout(resolve2, 3e3));
       }
     } else {
       const tabs = ocGetTabs();
@@ -2128,7 +1091,7 @@ async function siteRun(name, args, options) {
   let targetTabId = options.tabId;
   if (!targetTabId && site.domain) {
     const listReq = { id: generateId(), action: "tab_list" };
-    const listResp = await sendCommand2(listReq);
+    const listResp = await sendCommand(listReq);
     if (listResp.success && listResp.data?.tabs) {
       const matchingTab = listResp.data.tabs.find(
         (tab) => matchTabOrigin(tab.url, site.domain)
@@ -2138,17 +1101,17 @@ async function siteRun(name, args, options) {
       }
     }
     if (!targetTabId) {
-      const newResp = await sendCommand2({
+      const newResp = await sendCommand({
         id: generateId(),
         action: "tab_new",
         url: `https://${site.domain}`
       });
       targetTabId = newResp.data?.tabId;
-      await new Promise((resolve3) => setTimeout(resolve3, 3e3));
+      await new Promise((resolve2) => setTimeout(resolve2, 3e3));
     }
   }
   const evalReq = { id: generateId(), action: "eval", script, tabId: targetTabId };
-  const evalResp = await sendCommand2(evalReq);
+  const evalResp = await sendCommand(evalReq);
   if (!evalResp.success) {
     const hint = site.domain ? `Open https://${site.domain} in your browser, make sure you are logged in, then retry.` : void 0;
     if (options.json) {
@@ -2284,7 +1247,7 @@ async function siteCommand(args, options = {}) {
 }
 function silentUpdate() {
   const gitDir = join2(COMMUNITY_SITES_DIR, ".git");
-  if (!existsSync5(gitDir)) return;
+  if (!existsSync4(gitDir)) return;
   import("child_process").then(({ spawn: spawn3 }) => {
     const child = spawn3("git", ["pull", "--ff-only"], {
       cwd: COMMUNITY_SITES_DIR,
@@ -2322,7 +1285,7 @@ async function openCommand(url, options = {}) {
       request.tabId = tabId;
     }
   }
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2358,7 +1321,7 @@ async function snapshotCommand(options = {}) {
     selector: options.selector,
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2377,7 +1340,7 @@ async function snapshotCommand(options = {}) {
 }
 
 // packages/cli/src/commands/click.ts
-function parseRef2(ref) {
+function parseRef(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function clickCommand(ref, options = {}) {
@@ -2385,14 +1348,14 @@ async function clickCommand(ref, options = {}) {
     throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
   }
   await ensureDaemonRunning();
-  const parsedRef = parseRef2(ref);
+  const parsedRef = parseRef(ref);
   const request = {
     id: generateId(),
     action: "click",
     ref: parsedRef,
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2412,7 +1375,7 @@ async function clickCommand(ref, options = {}) {
 }
 
 // packages/cli/src/commands/hover.ts
-function parseRef3(ref) {
+function parseRef2(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function hoverCommand(ref, options = {}) {
@@ -2420,14 +1383,14 @@ async function hoverCommand(ref, options = {}) {
     throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
   }
   await ensureDaemonRunning();
-  const parsedRef = parseRef3(ref);
+  const parsedRef = parseRef2(ref);
   const request = {
     id: generateId(),
     action: "hover",
     ref: parsedRef,
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2447,7 +1410,7 @@ async function hoverCommand(ref, options = {}) {
 }
 
 // packages/cli/src/commands/fill.ts
-function parseRef4(ref) {
+function parseRef3(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function fillCommand(ref, text, options = {}) {
@@ -2458,7 +1421,7 @@ async function fillCommand(ref, text, options = {}) {
     throw new Error("\u7F3A\u5C11 text \u53C2\u6570");
   }
   await ensureDaemonRunning();
-  const parsedRef = parseRef4(ref);
+  const parsedRef = parseRef3(ref);
   const request = {
     id: generateId(),
     action: "fill",
@@ -2466,7 +1429,7 @@ async function fillCommand(ref, text, options = {}) {
     text,
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2487,7 +1450,7 @@ async function fillCommand(ref, text, options = {}) {
 }
 
 // packages/cli/src/commands/type.ts
-function parseRef5(ref) {
+function parseRef4(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function typeCommand(ref, text, options = {}) {
@@ -2498,7 +1461,7 @@ async function typeCommand(ref, text, options = {}) {
     throw new Error("\u7F3A\u5C11 text \u53C2\u6570");
   }
   await ensureDaemonRunning();
-  const parsedRef = parseRef5(ref);
+  const parsedRef = parseRef4(ref);
   const request = {
     id: generateId(),
     action: "type",
@@ -2506,7 +1469,7 @@ async function typeCommand(ref, text, options = {}) {
     text,
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2534,7 +1497,7 @@ async function closeCommand(options = {}) {
     action: "close",
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2553,7 +1516,7 @@ async function closeCommand(options = {}) {
 }
 
 // packages/cli/src/commands/get.ts
-function parseRef6(ref) {
+function parseRef5(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function getCommand(attribute, ref, options = {}) {
@@ -2565,10 +1528,10 @@ async function getCommand(attribute, ref, options = {}) {
     id: generateId(),
     action: "get",
     attribute,
-    ref: ref ? parseRef6(ref) : void 0,
+    ref: ref ? parseRef5(ref) : void 0,
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2584,17 +1547,17 @@ async function getCommand(attribute, ref, options = {}) {
 
 // packages/cli/src/commands/screenshot.ts
 import fs from "fs";
-import path4 from "path";
-import os4 from "os";
+import path3 from "path";
+import os3 from "os";
 function getDefaultPath() {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const filename = `bb-screenshot-${timestamp}.png`;
-  return path4.join(os4.tmpdir(), filename);
+  return path3.join(os3.tmpdir(), filename);
 }
 function saveBase64Image(dataUrl, filePath) {
   const base64Data = dataUrl.replace(/^data:image\/png;base64,/, "");
   const buffer = Buffer.from(base64Data, "base64");
-  const dir = path4.dirname(filePath);
+  const dir = path3.dirname(filePath);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
@@ -2602,13 +1565,13 @@ function saveBase64Image(dataUrl, filePath) {
 }
 async function screenshotCommand(outputPath, options = {}) {
   await ensureDaemonRunning();
-  const filePath = outputPath ? path4.resolve(outputPath) : getDefaultPath();
+  const filePath = outputPath ? path3.resolve(outputPath) : getDefaultPath();
   const request = {
     id: generateId(),
     action: "screenshot",
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (response.success && response.data?.dataUrl) {
     const dataUrl = response.data.dataUrl;
     saveBase64Image(dataUrl, filePath);
@@ -2635,7 +1598,7 @@ async function screenshotCommand(outputPath, options = {}) {
 function isTimeWait(target) {
   return /^\d+$/.test(target);
 }
-function parseRef7(ref) {
+function parseRef6(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function waitCommand(target, options = {}) {
@@ -2654,7 +1617,7 @@ async function waitCommand(target, options = {}) {
       tabId: options.tabId
     };
   } else {
-    const ref = parseRef7(target);
+    const ref = parseRef6(target);
     request = {
       id: generateId(),
       action: "wait",
@@ -2663,7 +1626,7 @@ async function waitCommand(target, options = {}) {
       tabId: options.tabId
     };
   }
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2671,7 +1634,7 @@ async function waitCommand(target, options = {}) {
       if (isTimeWait(target)) {
         console.log(`\u5DF2\u7B49\u5F85 ${target}ms`);
       } else {
-        console.log(`\u5143\u7D20 @${parseRef7(target)} \u5DF2\u51FA\u73B0`);
+        console.log(`\u5143\u7D20 @${parseRef6(target)} \u5DF2\u51FA\u73B0`);
       }
     } else {
       console.error(`\u9519\u8BEF: ${response.error}`);
@@ -2711,7 +1674,7 @@ async function pressCommand(keyString, options = {}) {
     modifiers,
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2752,7 +1715,7 @@ async function scrollCommand(direction, pixels, options = {}) {
     pixels: pixelValue,
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2773,7 +1736,7 @@ async function backCommand(options = {}) {
     action: "back",
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2797,7 +1760,7 @@ async function forwardCommand(options = {}) {
     action: "forward",
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2821,7 +1784,7 @@ async function refreshCommand(options = {}) {
     action: "refresh",
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2840,7 +1803,7 @@ async function refreshCommand(options = {}) {
 }
 
 // packages/cli/src/commands/check.ts
-function parseRef8(ref) {
+function parseRef7(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function checkCommand(ref, options = {}) {
@@ -2848,14 +1811,14 @@ async function checkCommand(ref, options = {}) {
     throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
   }
   await ensureDaemonRunning();
-  const parsedRef = parseRef8(ref);
+  const parsedRef = parseRef7(ref);
   const request = {
     id: generateId(),
     action: "check",
     ref: parsedRef,
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2887,14 +1850,14 @@ async function uncheckCommand(ref, options = {}) {
     throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
   }
   await ensureDaemonRunning();
-  const parsedRef = parseRef8(ref);
+  const parsedRef = parseRef7(ref);
   const request = {
     id: generateId(),
     action: "uncheck",
     ref: parsedRef,
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2923,7 +1886,7 @@ async function uncheckCommand(ref, options = {}) {
 }
 
 // packages/cli/src/commands/select.ts
-function parseRef9(ref) {
+function parseRef8(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function selectCommand(ref, value, options = {}) {
@@ -2934,7 +1897,7 @@ async function selectCommand(ref, value, options = {}) {
     throw new Error("\u7F3A\u5C11 value \u53C2\u6570");
   }
   await ensureDaemonRunning();
-  const parsedRef = parseRef9(ref);
+  const parsedRef = parseRef8(ref);
   const request = {
     id: generateId(),
     action: "select",
@@ -2942,7 +1905,7 @@ async function selectCommand(ref, value, options = {}) {
     value,
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -2980,7 +1943,7 @@ async function evalCommand(script, options = {}) {
     script,
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -3063,6 +2026,12 @@ function formatTabList(tabs, activeIndex) {
 async function tabCommand(args, options = {}) {
   await ensureDaemonRunning();
   const parsed = parseTabSubcommand(args, process.argv);
+  if (options.globalTabId && parsed.tabId === void 0 && parsed.index === void 0) {
+    if (parsed.action === "tab_close" || parsed.action === "tab_select") {
+      const numId = parseInt(options.globalTabId, 10);
+      parsed.tabId = isNaN(numId) ? options.globalTabId : numId;
+    }
+  }
   const request = {
     id: generateId(),
     action: parsed.action,
@@ -3070,7 +2039,7 @@ async function tabCommand(args, options = {}) {
     index: parsed.index,
     tabId: parsed.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -3119,7 +2088,7 @@ async function frameCommand(selector, options = {}) {
     selector,
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -3143,7 +2112,7 @@ async function frameMainCommand(options = {}) {
     action: "frame_main",
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -3169,7 +2138,7 @@ async function dialogCommand(subCommand, promptText, options = {}) {
     promptText: subCommand === "accept" ? promptText : void 0,
     tabId: options.tabId
   };
-  const response = await sendCommand2(request);
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -3190,7 +2159,12 @@ async function dialogCommand(subCommand, promptText, options = {}) {
 
 // packages/cli/src/commands/network.ts
 async function networkCommand(subCommand, urlOrFilter, options = {}) {
-  const response = await sendCommand2({
+  let since;
+  if (subCommand === "requests" && options.since) {
+    const num = parseInt(options.since, 10);
+    since = !isNaN(num) && String(num) === options.since ? num : options.since;
+  }
+  const request = {
     id: generateId(),
     action: "network",
     networkCommand: subCommand,
@@ -3201,8 +2175,12 @@ async function networkCommand(subCommand, urlOrFilter, options = {}) {
       body: options.body
     } : void 0,
     withBody: subCommand === "requests" ? options.withBody : void 0,
+    since,
+    method: subCommand === "requests" ? options.method : void 0,
+    status: subCommand === "requests" ? options.status : void 0,
     tabId: options.tabId
-  });
+  };
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response));
     return;
@@ -3277,12 +2255,19 @@ async function networkCommand(subCommand, urlOrFilter, options = {}) {
 
 // packages/cli/src/commands/console.ts
 async function consoleCommand(options = {}) {
-  const response = await sendCommand2({
+  let since;
+  if (options.since) {
+    const num = parseInt(options.since, 10);
+    since = !isNaN(num) && String(num) === options.since ? num : options.since;
+  }
+  const request = {
     id: generateId(),
     action: "console",
     consoleCommand: options.clear ? "clear" : "get",
-    tabId: options.tabId
-  });
+    tabId: options.tabId,
+    since
+  };
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response));
     return;
@@ -3322,12 +2307,19 @@ async function consoleCommand(options = {}) {
 
 // packages/cli/src/commands/errors.ts
 async function errorsCommand(options = {}) {
-  const response = await sendCommand2({
+  let since;
+  if (options.since) {
+    const num = parseInt(options.since, 10);
+    since = !isNaN(num) && String(num) === options.since ? num : options.since;
+  }
+  const request = {
     id: generateId(),
     action: "errors",
     errorsCommand: options.clear ? "clear" : "get",
-    tabId: options.tabId
-  });
+    tabId: options.tabId,
+    since
+  };
+  const response = await sendCommand(request);
   if (options.json) {
     console.log(JSON.stringify(response));
     return;
@@ -3362,7 +2354,7 @@ async function errorsCommand(options = {}) {
 
 // packages/cli/src/commands/trace.ts
 async function traceCommand(subCommand, options = {}) {
-  const response = await sendCommand2({
+  const response = await sendCommand({
     id: generateId(),
     action: "trace",
     traceCommand: subCommand,
@@ -3452,7 +2444,7 @@ function matchTabOrigin2(tabUrl, targetHostname) {
 }
 async function ensureTabForOrigin(origin, hostname) {
   const listReq = { id: generateId(), action: "tab_list" };
-  const listResp = await sendCommand2(listReq);
+  const listResp = await sendCommand(listReq);
   if (listResp.success && listResp.data?.tabs) {
     const matchingTab = listResp.data.tabs.find(
       (tab) => matchTabOrigin2(tab.url, hostname)
@@ -3461,11 +2453,11 @@ async function ensureTabForOrigin(origin, hostname) {
       return matchingTab.tabId;
     }
   }
-  const newResp = await sendCommand2({ id: generateId(), action: "tab_new", url: origin });
+  const newResp = await sendCommand({ id: generateId(), action: "tab_new", url: origin });
   if (!newResp.success) {
     throw new Error(`\u65E0\u6CD5\u6253\u5F00 ${origin}: ${newResp.error}`);
   }
-  await new Promise((resolve3) => setTimeout(resolve3, 3e3));
+  await new Promise((resolve2) => setTimeout(resolve2, 3e3));
   return newResp.data?.tabId;
 }
 function buildFetchScript(url, options) {
@@ -3530,7 +2522,7 @@ async function fetchCommand(url, options = {}) {
   }
   const script = buildFetchScript(url, options);
   const evalReq = { id: generateId(), action: "eval", script, tabId: targetTabId };
-  const evalResp = await sendCommand2(evalReq);
+  const evalResp = await sendCommand(evalReq);
   if (!evalResp.success) {
     throw new Error(`Fetch \u5931\u8D25: ${evalResp.error}`);
   }
@@ -3549,9 +2541,9 @@ async function fetchCommand(url, options = {}) {
     throw new Error(`Fetch error: ${result.error}`);
   }
   if (options.output) {
-    const { writeFileSync: writeFileSync2 } = await import("fs");
+    const { writeFileSync } = await import("fs");
     const content = typeof result.body === "object" ? JSON.stringify(result.body, null, 2) : String(result.body);
-    writeFileSync2(options.output, content, "utf-8");
+    writeFileSync(options.output, content, "utf-8");
     console.log(`\u5DF2\u5199\u5165 ${options.output} (${result.status}, ${content.length} bytes)`);
     return;
   }
@@ -3613,16 +2605,57 @@ async function historyCommand(subCommand, options = {}) {
 
 // packages/cli/src/commands/daemon.ts
 async function statusCommand(options = {}) {
-  const running = await isDaemonRunning();
+  const status = await getDaemonStatus();
+  if (!status) {
+    if (options.json) {
+      console.log(JSON.stringify({ running: false }));
+    } else {
+      console.log("Daemon not running");
+    }
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(status, null, 2));
+    return;
+  }
+  console.log(`Daemon running: ${status.running ? "yes" : "no"}`);
+  console.log(`CDP connected:  ${status.cdpConnected ? "yes" : "no"}`);
+  console.log(`Uptime:         ${formatUptime(status.uptime)}`);
+  console.log(`Global seq:     ${status.currentSeq ?? "N/A"}`);
+  const tabs = status.tabs;
+  if (tabs && tabs.length > 0) {
+    console.log(`
+Tabs (${tabs.length}):`);
+    for (const tab of tabs) {
+      const active = tab.targetId === status.currentTargetId ? " *" : "";
+      console.log(
+        `  ${tab.shortId}${active}  net:${tab.networkRequests} console:${tab.consoleMessages} err:${tab.jsErrors} seq:${tab.lastActionSeq}`
+      );
+    }
+  } else {
+    console.log("\nNo tabs");
+  }
+}
+async function shutdownCommand(options = {}) {
+  const ok = await stopDaemon();
   if (options.json) {
-    console.log(JSON.stringify({ running }));
+    console.log(JSON.stringify({ stopped: ok }));
   } else {
-    console.log(running ? "\u6D4F\u89C8\u5668\u8FD0\u884C\u4E2D" : "\u6D4F\u89C8\u5668\u672A\u8FD0\u884C");
+    console.log(ok ? "Daemon stopped" : "Daemon was not running");
   }
 }
+function formatUptime(ms) {
+  if (!ms || ms <= 0) return "0s";
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${s % 60}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h ${m % 60}m`;
+}
 
 // packages/cli/src/index.ts
-var VERSION = "0.10.1";
+var VERSION = "0.11.1";
 var HELP_TEXT = `
 bb-browser - AI Agent \u6D4F\u89C8\u5668\u81EA\u52A8\u5316\u5DE5\u5177
 
@@ -3677,6 +2710,7 @@ bb-browser - AI Agent \u6D4F\u89C8\u5668\u81EA\u52A8\u5316\u5DE5\u5177
   errors [--clear]             \u67E5\u770B/\u6E05\u7A7A JS \u9519\u8BEF
   trace start|stop|status      \u5F55\u5236\u7528\u6237\u64CD\u4F5C
   history search|domains       \u67E5\u770B\u6D4F\u89C8\u5386\u53F2
+  daemon [status|stop] [opts]  \u524D\u53F0\u8FD0\u884C\u6216\u7BA1\u7406 daemon
 
 \u9009\u9879\uFF1A
   --json               \u4EE5 JSON \u683C\u5F0F\u8F93\u51FA
@@ -3758,6 +2792,12 @@ function parseArgs(argv) {
       skipNext = true;
     } else if (arg === "--tab") {
       skipNext = true;
+    } else if (arg === "--since") {
+      skipNext = true;
+    } else if (arg === "--method") {
+      skipNext = true;
+    } else if (arg === "--status") {
+      skipNext = true;
     } else if (arg.startsWith("-")) {
     } else if (result.command === null) {
       result.command = arg;
@@ -3771,19 +2811,25 @@ async function main() {
   const parsed = parseArgs(process.argv);
   setJqExpression(parsed.flags.jq);
   const tabArgIdx = process.argv.indexOf("--tab");
-  const globalTabId = tabArgIdx >= 0 && process.argv[tabArgIdx + 1] ? parseInt(process.argv[tabArgIdx + 1], 10) : void 0;
+  const globalTabId = tabArgIdx >= 0 && process.argv[tabArgIdx + 1] ? process.argv[tabArgIdx + 1] : void 0;
+  const sinceArgIdx = process.argv.indexOf("--since");
+  const globalSince = sinceArgIdx >= 0 && process.argv[sinceArgIdx + 1] ? process.argv[sinceArgIdx + 1] : void 0;
   if (parsed.flags.version) {
     console.log(VERSION);
     return;
   }
   if (process.argv.includes("--mcp")) {
-    const mcpPath = fileURLToPath4(new URL("./mcp.js", import.meta.url));
+    const mcpPath = fileURLToPath2(new URL("./mcp.js", import.meta.url));
     const { spawn: spawn3 } = await import("child_process");
     const child = spawn3(process.execPath, [mcpPath], { stdio: "inherit" });
     child.on("exit", (code) => process.exit(code ?? 0));
     return;
   }
-  if (parsed.flags.help || !parsed.command) {
+  if (!parsed.command) {
+    console.log(HELP_TEXT);
+    return;
+  }
+  if (parsed.flags.help && parsed.command !== "daemon") {
     console.log(HELP_TEXT);
     return;
   }
@@ -3939,7 +2985,31 @@ async function main() {
         await getCommand(attribute, ref, { json: parsed.flags.json, tabId: globalTabId });
         break;
       }
-      case "daemon":
+      case "daemon": {
+        const daemonSubcommand = parsed.args[0];
+        if (daemonSubcommand === "status") {
+          await statusCommand({ json: parsed.flags.json });
+          break;
+        }
+        if (daemonSubcommand === "stop" || daemonSubcommand === "shutdown") {
+          await shutdownCommand({ json: parsed.flags.json });
+          break;
+        }
+        const daemonPath = getDaemonPath();
+        const daemonArgs = process.argv.slice(3);
+        const { spawn: spawn3 } = await import("child_process");
+        const child = spawn3(process.execPath, [daemonPath, ...daemonArgs], {
+          stdio: "inherit"
+        });
+        child.on("exit", (code, signal) => {
+          if (signal) {
+            process.kill(process.pid, signal);
+            return;
+          }
+          process.exit(code ?? 0);
+        });
+        return;
+      }
       case "close": {
         await closeCommand({ json: parsed.flags.json, tabId: globalTabId });
         break;
@@ -3999,7 +3069,7 @@ async function main() {
         break;
       }
       case "tab": {
-        await tabCommand(parsed.args, { json: parsed.flags.json });
+        await tabCommand(parsed.args, { json: parsed.flags.json, globalTabId });
         break;
       }
       case "status": {
@@ -4043,17 +3113,21 @@ async function main() {
         const withBody = process.argv.includes("--with-body");
         const bodyIndex = process.argv.findIndex((a) => a === "--body");
         const body = bodyIndex >= 0 ? process.argv[bodyIndex + 1] : void 0;
-        await networkCommand(subCommand, urlOrFilter, { json: parsed.flags.json, abort, body, withBody, tabId: globalTabId });
+        const methodIndex = process.argv.findIndex((a) => a === "--method");
+        const method = methodIndex >= 0 ? process.argv[methodIndex + 1] : void 0;
+        const statusIndex = process.argv.findIndex((a) => a === "--status");
+        const statusFilter = statusIndex >= 0 ? process.argv[statusIndex + 1] : void 0;
+        await networkCommand(subCommand, urlOrFilter, { json: parsed.flags.json, abort, body, withBody, tabId: globalTabId, since: globalSince, method, status: statusFilter });
         break;
       }
       case "console": {
         const clear = process.argv.includes("--clear");
-        await consoleCommand({ json: parsed.flags.json, clear, tabId: globalTabId });
+        await consoleCommand({ json: parsed.flags.json, clear, tabId: globalTabId, since: globalSince });
         break;
       }
       case "errors": {
         const clear = process.argv.includes("--clear");
-        await errorsCommand({ json: parsed.flags.json, clear, tabId: globalTabId });
+        await errorsCommand({ json: parsed.flags.json, clear, tabId: globalTabId, since: globalSince });
         break;
       }
       case "trace": {