bb-browser 0.7.0 → 0.8.0

package/dist/cli.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import {
   COMMAND_TIMEOUT,
-  DAEMON_BASE_URL,
   generateId
 } from "./chunk-DBJBHYC7.js";
 import {
@@ -10,7 +9,858 @@ import {
 import "./chunk-D4HDZEJT.js";
 
 // packages/cli/src/index.ts
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// packages/cli/src/cdp-client.ts
+import { readFileSync } from "fs";
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+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";
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import os from "os";
+import path from "path";
+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");
+function execFileAsync(command, args, timeout) {
+  return new Promise((resolve2, reject) => {
+    execFile(command, args, { encoding: "utf8", timeout }, (error, stdout) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve2(stdout.trim());
+    });
+  });
+}
+function getArgValue(flag) {
+  const index = process.argv.indexOf(flag);
+  if (index < 0) return void 0;
+  return process.argv[index + 1];
+}
+async function tryOpenClaw() {
+  try {
+    const raw = await execFileAsync("npx", ["openclaw", "browser", "status", "--json"], 5e3);
+    const parsed = JSON.parse(raw);
+    const port = Number(parsed?.cdpPort);
+    if (Number.isInteger(port) && port > 0) {
+      return { host: "127.0.0.1", port };
+    }
+  } catch {
+  }
+  return null;
+}
+async function canConnect(host, port) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1200);
+    const response = await fetch(`http://${host}:${port}/json/version`, { signal: controller.signal });
+    clearTimeout(timeout);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function findBrowserExecutable() {
+  if (process.platform === "darwin") {
+    const candidates = [
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+      "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? null;
+  }
+  if (process.platform === "linux") {
+    const candidates = ["google-chrome", "google-chrome-stable", "chromium-browser", "chromium"];
+    for (const candidate of candidates) {
+      try {
+        const resolved = execSync(`which ${candidate}`, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+        if (resolved) {
+          return resolved;
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  if (process.platform === "win32") {
+    const candidates = [
+      "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+      "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+      "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe"
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? null;
+  }
+  return null;
+}
+async function launchManagedBrowser(port = DEFAULT_CDP_PORT) {
+  const executable = findBrowserExecutable();
+  if (!executable) {
+    return null;
+  }
+  await mkdir(MANAGED_USER_DATA_DIR, { recursive: true });
+  const defaultProfileDir = path.join(MANAGED_USER_DATA_DIR, "Default");
+  const prefsPath = path.join(defaultProfileDir, "Preferences");
+  await mkdir(defaultProfileDir, { recursive: true });
+  try {
+    let prefs = {};
+    try {
+      prefs = JSON.parse(await readFile(prefsPath, "utf8"));
+    } catch {
+    }
+    if (!prefs.profile?.name || prefs.profile.name !== "bb-browser") {
+      prefs.profile = { ...prefs.profile || {}, name: "bb-browser" };
+      await writeFile(prefsPath, JSON.stringify(prefs), "utf8");
+    }
+  } catch {
+  }
+  const args = [
+    `--remote-debugging-port=${port}`,
+    `--user-data-dir=${MANAGED_USER_DATA_DIR}`,
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-sync",
+    "--disable-background-networking",
+    "--disable-component-update",
+    "--disable-features=Translate,MediaRouter",
+    "--disable-session-crashed-bubble",
+    "--hide-crash-restore-bubble",
+    "about:blank"
+  ];
+  try {
+    const child = spawn(executable, args, {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+  } catch {
+    return null;
+  }
+  await mkdir(MANAGED_BROWSER_DIR, { recursive: true });
+  await writeFile(MANAGED_PORT_FILE, String(port), "utf8");
+  const deadline = Date.now() + 8e3;
+  while (Date.now() < deadline) {
+    if (await canConnect("127.0.0.1", port)) {
+      return { host: "127.0.0.1", port };
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 250));
+  }
+  return null;
+}
+async function discoverCdpPort() {
+  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 };
+  }
+  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;
+  }
+  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 {
+  }
+  return launchManagedBrowser();
+}
+
+// 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 buildRequestError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function fetchJson(url) {
+  return new Promise((resolve2, 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 {
+          resolve2(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((resolve2, reject) => {
+    const ws = new WebSocket(url);
+    ws.once("open", () => resolve2(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(),
+    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);
+        }
+      }
+      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((resolve2, reject) => {
+    state.browserPending.set(id, { resolve: resolve2, 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((resolve2, 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 resolve2(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");
+  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);
+  }
+  target ??= targets[0];
+  connectionState.currentTargetId = target.id;
+  await attachTarget(target.id);
+  return target;
+}
+function parseRef(ref) {
+  const refs = connectionState?.refsByTarget.get(connectionState.currentTargetId ?? "") ?? {};
+  const found = refs[ref];
+  if (!found?.backendDOMNodeId) {
+    throw new Error(`Unknown ref: ${ref}. Run snapshot first.`);
+  }
+  return found.backendDOMNodeId;
+}
+function loadBuildDomTreeScript() {
+  const currentDir = path2.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path2.resolve(currentDir, "../../../extension/buildDomTree.js"),
+    path2.resolve(currentDir, "../../extension/buildDomTree.js"),
+    path2.resolve(currentDir, "../../../packages/extension/buildDomTree.js"),
+    path2.resolve(currentDir, "../../../extension/dist/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.text || "Runtime.evaluate failed");
+  }
+  return result.result.value ?? result.result;
+}
+async function resolveNode(targetId, backendNodeId) {
+  const result = await sessionCommand(targetId, "DOM.pushNodesByBackendIdsToFrontend", {
+    backendNodeIds: [backendNodeId]
+  });
+  return result.nodeId;
+}
+async function focusNode(targetId, backendNodeId) {
+  const nodeId = await resolveNode(targetId, backendNodeId);
+  await sessionCommand(targetId, "DOM.focus", { nodeId });
+}
+async function getNodeBox(targetId, backendNodeId) {
+  const result = await sessionCommand(targetId, "DOM.getBoxModel", {
+    backendNodeId
+  });
+  const quad = result.model.content.length >= 8 ? result.model.content : result.model.border;
+  const xs = [quad[0], quad[2], quad[4], quad[6]];
+  const ys = [quad[1], quad[3], quad[5], quad[7]];
+  return {
+    x: xs.reduce((a, b) => a + b, 0) / xs.length,
+    y: ys.reduce((a, b) => a + b, 0) / ys.length
+  };
+}
+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) {
+  const nodeId = await resolveNode(targetId, backendNodeId);
+  if (attribute === "text") {
+    return evaluate(targetId, `(() => { const n = this; return n.innerText ?? n.textContent ?? ''; }).call(document.querySelector('[data-bb-node-id="${nodeId}"]'))`);
+  }
+  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 expression = `(() => { ${script}; return (typeof buildDomTree === 'function' ? buildDomTree : globalThis.buildDomTree)(${JSON.stringify({
+    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;
+}
+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 });
+        const newTarget = await ensurePageTarget(created.targetId);
+        return ok(request.id, { url: request.url, tabId: Number(newTarget.id) || void 0 });
+      }
+      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 });
+    }
+    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 = 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);
+      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 = 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 });
+      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 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 = 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.ref || !request.attribute) return fail(request.id, "Missing ref or attribute parameter");
+      const value = await getAttributeValue(target.id, 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 });
+      return ok(request.id, {});
+    }
+    case "wait": {
+      await new Promise((resolve2) => setTimeout(resolve2, 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: Number(item.id) || index }));
+      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" });
+    }
+    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");
+      connectionState.currentTargetId = selected.id;
+      await attachTarget(selected.id);
+      return ok(request.id, { tabId: Number(selected.id) || void 0, 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 });
+    }
+    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/client.ts
 var jqExpression;
@@ -30,184 +880,190 @@ function handleJqResponse(response) {
     printJqResults(response);
   }
 }
-async function sendCommand(request) {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), COMMAND_TIMEOUT);
-  try {
-    const res = await fetch(`${DAEMON_BASE_URL}/command`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(request),
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-    if (!res.ok) {
-      if (res.status === 408) {
-        return {
-          id: request.id,
-          success: false,
-          error: "\u547D\u4EE4\u6267\u884C\u8D85\u65F6"
-        };
-      }
-      if (res.status === 503) {
-        return {
-          id: request.id,
-          success: false,
-          error: [
-            "Chrome extension not connected.",
-            "",
-            "1. Download extension: https://github.com/epiral/bb-browser/releases/latest",
-            "2. Unzip the downloaded file",
-            "3. Open chrome://extensions/ \u2192 Enable Developer Mode",
-            '4. Click "Load unpacked" \u2192 select the unzipped folder'
-          ].join("\n")
-        };
-      }
-      return {
-        id: request.id,
-        success: false,
-        error: `HTTP \u9519\u8BEF: ${res.status} ${res.statusText}`
-      };
-    }
-    const response = await res.json();
-    return response;
-  } catch (error) {
-    clearTimeout(timeoutId);
-    if (error instanceof Error) {
-      if (error.name === "AbortError") {
-        return {
-          id: request.id,
-          success: false,
-          error: "\u8BF7\u6C42\u8D85\u65F6"
-        };
-      }
-      if (error.message.includes("fetch failed") || error.message.includes("ECONNREFUSED")) {
-        throw new Error([
-          "Cannot connect to daemon.",
-          "",
-          "Start the daemon first:",
-          "  bb-browser daemon",
-          "",
-          "Then load the Chrome extension:",
-          "  chrome://extensions/ \u2192 Developer Mode \u2192 Load unpacked \u2192 node_modules/bb-browser/extension/"
-        ].join("\n"));
-      }
-      throw error;
-    }
-    throw error;
-  }
+async function sendCommand2(request) {
+  return sendCommand(request);
 }
 
 // packages/cli/src/daemon-manager.ts
-import { spawn } from "child_process";
-import { existsSync } from "fs";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname, resolve } from "path";
-function getDaemonPath() {
-  const currentFile = fileURLToPath(import.meta.url);
-  const currentDir = dirname(currentFile);
-  const sameDirPath = resolve(currentDir, "daemon.js");
-  if (existsSync(sameDirPath)) {
-    return sameDirPath;
-  }
-  return resolve(currentDir, "../../daemon/dist/index.js");
-}
-var DAEMON_START_TIMEOUT = 5e3;
-var POLL_INTERVAL = 200;
+import { existsSync as existsSync2 } from "fs";
 async function isDaemonRunning() {
+  return await discoverCdpPort() !== null;
+}
+async function ensureDaemonRunning() {
   try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 2e3);
-    const response = await fetch(`${DAEMON_BASE_URL}/status`, {
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-    return response.ok;
-  } catch {
-    return false;
+    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 isExtensionConnected() {
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 2e3);
-    const response = await fetch(`${DAEMON_BASE_URL}/status`, {
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-    if (!response.ok) return false;
-    const data = await response.json();
-    return !!data.extensionConnected;
-  } catch {
-    return false;
+
+// packages/cli/src/history-sqlite.ts
+import { copyFileSync, existsSync as existsSync3, unlinkSync } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { homedir, tmpdir } from "os";
+import { join } from "path";
+function getHistoryPathCandidates() {
+  const home = homedir();
+  const localAppData = process.env.LOCALAPPDATA || "";
+  const candidates = [
+    join(home, "Library/Application Support/Google/Chrome/Default/History"),
+    join(home, "Library/Application Support/Microsoft Edge/Default/History"),
+    join(home, "Library/Application Support/BraveSoftware/Brave-Browser/Default/History"),
+    join(home, "Library/Application Support/Arc/User Data/Default/History"),
+    join(home, ".config/google-chrome/Default/History")
+  ];
+  if (localAppData) {
+    candidates.push(
+      join(localAppData, "Google/Chrome/User Data/Default/History"),
+      join(localAppData, "Microsoft/Edge/User Data/Default/History")
+    );
   }
+  return candidates;
 }
-async function waitForDaemon(timeoutMs) {
-  const startTime = Date.now();
-  while (Date.now() - startTime < timeoutMs) {
-    if (await isDaemonRunning()) {
-      return true;
+function findHistoryPath() {
+  for (const historyPath of getHistoryPathCandidates()) {
+    if (existsSync3(historyPath)) {
+      return historyPath;
     }
-    await new Promise((resolve2) => setTimeout(resolve2, POLL_INTERVAL));
   }
-  return false;
+  return null;
 }
-function spawnDaemon() {
-  const daemonPath = getDaemonPath();
-  const daemonProcess = spawn(process.execPath, [daemonPath], {
-    detached: true,
-    stdio: "ignore",
-    env: { ...process.env }
-  });
-  daemonProcess.unref();
+function sqlEscape(value) {
+  return value.replace(/'/g, "''");
 }
-async function ensureDaemonRunning() {
-  if (await isDaemonRunning()) {
-    return;
-  }
-  spawnDaemon();
-  const ready = await waitForDaemon(DAEMON_START_TIMEOUT);
-  if (!ready) {
-    throw new Error(
-      "\u65E0\u6CD5\u542F\u52A8 Daemon\u3002\u8BF7\u624B\u52A8\u8FD0\u884C bb-browser daemon \u6216 bb-daemon \u542F\u52A8\u670D\u52A1"
-    );
-  }
-  const extStart = Date.now();
-  while (Date.now() - extStart < 1e4) {
-    if (await isExtensionConnected()) return;
-    await new Promise((r) => setTimeout(r, POLL_INTERVAL));
+function buildTimeWhere(days) {
+  if (!days || days <= 0) {
+    return "";
   }
+  return `last_visit_time > (strftime('%s', 'now') - ${Math.floor(days)}*86400) * 1000000 + 11644473600000000`;
 }
-async function stopDaemon() {
+function runHistoryQuery(sql, mapRow) {
+  const historyPath = findHistoryPath();
+  if (!historyPath) {
+    return [];
+  }
+  const tmpPath = join(tmpdir(), `bb-history-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
   try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 5e3);
-    const response = await fetch(`${DAEMON_BASE_URL}/shutdown`, {
-      method: "POST",
-      signal: controller.signal
+    copyFileSync(historyPath, tmpPath);
+    const escapedTmpPath = tmpPath.replace(/"/g, '\\"');
+    const escapedSql = sql.replace(/"/g, '\\"');
+    const output = execSync2(`sqlite3 -separator $'\\t' "${escapedTmpPath}" "${escapedSql}"`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
     });
-    clearTimeout(timeoutId);
-    return response.ok;
+    return output.split("\n").filter(Boolean).map((line) => mapRow(line.split("	"))).filter((item) => item !== null);
   } catch {
-    return false;
+    return [];
+  } finally {
+    try {
+      unlinkSync(tmpPath);
+    } catch {
+    }
   }
 }
+function searchHistory(query, days) {
+  const conditions = [];
+  const trimmedQuery = query?.trim();
+  if (trimmedQuery) {
+    const escapedQuery = sqlEscape(trimmedQuery);
+    conditions.push(`(url LIKE '%${escapedQuery}%' OR title LIKE '%${escapedQuery}%')`);
+  }
+  const timeWhere = buildTimeWhere(days);
+  if (timeWhere) {
+    conditions.push(timeWhere);
+  }
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const sql = `
+    SELECT
+      url,
+      REPLACE(IFNULL(title, ''), char(9), ' '),
+      IFNULL(visit_count, 0),
+      IFNULL(last_visit_time, 0)
+    FROM urls
+    ${whereClause}
+    ORDER BY last_visit_time DESC
+    LIMIT 100;
+  `.trim();
+  return runHistoryQuery(sql, (row) => {
+    if (row.length < 4) {
+      return null;
+    }
+    const chromeTimestamp = Number(row[3]) || 0;
+    return {
+      url: row[0] || "",
+      title: row[1] || "",
+      visitCount: Number(row[2]) || 0,
+      lastVisitTime: chromeTimestamp > 0 ? chromeTimestamp / 1e6 - 11644473600 : 0
+    };
+  });
+}
+function getHistoryDomains(days) {
+  const timeWhere = buildTimeWhere(days);
+  const whereClause = timeWhere ? `WHERE ${timeWhere}` : "";
+  const sql = `
+    SELECT
+      domain,
+      SUM(visit_count) AS visits,
+      GROUP_CONCAT(title, char(31)) AS titles
+    FROM (
+      SELECT
+        CASE
+          WHEN instr(url, '//') > 0 AND instr(substr(url, instr(url, '//') + 2), '/') > 0
+            THEN substr(
+              substr(url, instr(url, '//') + 2),
+              1,
+              instr(substr(url, instr(url, '//') + 2), '/') - 1
+            )
+          WHEN instr(url, '//') > 0 THEN substr(url, instr(url, '//') + 2)
+          WHEN instr(url, '/') > 0 THEN substr(url, 1, instr(url, '/') - 1)
+          ELSE url
+        END AS domain,
+        IFNULL(visit_count, 0) AS visit_count,
+        REPLACE(IFNULL(title, ''), char(31), ' ') AS title
+      FROM urls
+      ${whereClause}
+    )
+    WHERE domain != ''
+    GROUP BY domain
+    ORDER BY visits DESC
+    LIMIT 50;
+  `.trim();
+  return runHistoryQuery(sql, (row) => {
+    if (row.length < 3) {
+      return null;
+    }
+    const titles = row[2] ? Array.from(new Set(row[2].split(String.fromCharCode(31)).map((title) => title.trim()).filter(Boolean))).slice(0, 10) : [];
+    return {
+      domain: row[0] || "",
+      visits: Number(row[1]) || 0,
+      titles
+    };
+  });
+}
 
 // packages/cli/src/commands/site.ts
-import { readFileSync, readdirSync, existsSync as existsSync2, mkdirSync } from "fs";
-import { join, relative } from "path";
-import { homedir } from "os";
-import { execSync } from "child_process";
-var BB_DIR = join(homedir(), ".bb-browser");
-var LOCAL_SITES_DIR = join(BB_DIR, "sites");
-var COMMUNITY_SITES_DIR = join(BB_DIR, "bb-sites");
+import { readFileSync as readFileSync2, 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";
+var BB_DIR = join2(homedir2(), ".bb-browser");
+var LOCAL_SITES_DIR = join2(BB_DIR, "sites");
+var COMMUNITY_SITES_DIR = join2(BB_DIR, "bb-sites");
 var COMMUNITY_REPO = "https://github.com/epiral/bb-sites.git";
 function checkCliUpdate() {
   try {
-    const current = execSync("bb-browser --version", { timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
-    const latest = execSync("npm view bb-browser version", { timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+    const current = execSync3("bb-browser --version", { timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+    const latest = execSync3("npm view bb-browser version", { timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
     if (latest && current && latest !== current && latest.localeCompare(current, void 0, { numeric: true }) > 0) {
       console.log(`
 \u{1F4E6} bb-browser ${latest} available (current: ${current}). Run: npm install -g bb-browser`);
@@ -218,7 +1074,7 @@ function checkCliUpdate() {
 function parseSiteMeta(filePath, source) {
   let content;
   try {
-    content = readFileSync(filePath, "utf-8");
+    content = readFileSync2(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -278,7 +1134,7 @@ function parseSiteMeta(filePath, source) {
   return meta;
 }
 function scanSites(dir, source) {
-  if (!existsSync2(dir)) return [];
+  if (!existsSync4(dir)) return [];
   const sites = [];
   function walk(currentDir) {
     let entries;
@@ -288,7 +1144,7 @@ function scanSites(dir, source) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = join(currentDir, entry.name);
+      const fullPath = join2(currentDir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         walk(fullPath);
       } else if (entry.isFile() && entry.name.endsWith(".js")) {
@@ -392,10 +1248,10 @@ function siteSearch(query, options) {
 }
 function siteUpdate() {
   mkdirSync(BB_DIR, { recursive: true });
-  if (existsSync2(join(COMMUNITY_SITES_DIR, ".git"))) {
+  if (existsSync4(join2(COMMUNITY_SITES_DIR, ".git"))) {
     console.log("\u66F4\u65B0\u793E\u533A site adapter \u5E93...");
     try {
-      execSync("git pull --ff-only", { cwd: COMMUNITY_SITES_DIR, stdio: "pipe" });
+      execSync3("git pull --ff-only", { cwd: COMMUNITY_SITES_DIR, stdio: "pipe" });
       console.log("\u66F4\u65B0\u5B8C\u6210\u3002");
       console.log("");
       console.log("\u{1F4A1} \u8FD0\u884C bb-browser site recommend \u770B\u770B\u54EA\u4E9B\u548C\u4F60\u7684\u6D4F\u89C8\u4E60\u60EF\u5339\u914D");
@@ -407,7 +1263,7 @@ function siteUpdate() {
   } else {
     console.log(`\u514B\u9686\u793E\u533A adapter \u5E93: ${COMMUNITY_REPO}`);
     try {
-      execSync(`git clone ${COMMUNITY_REPO} ${COMMUNITY_SITES_DIR}`, { stdio: "pipe" });
+      execSync3(`git clone ${COMMUNITY_REPO} ${COMMUNITY_SITES_DIR}`, { stdio: "pipe" });
       console.log("\u514B\u9686\u5B8C\u6210\u3002");
       console.log("");
       console.log("\u{1F4A1} \u8FD0\u884C bb-browser site recommend \u770B\u770B\u54EA\u4E9B\u548C\u4F60\u7684\u6D4F\u89C8\u4E60\u60EF\u5339\u914D");
@@ -466,16 +1322,7 @@ function siteInfo(name, options) {
 }
 async function siteRecommend(options) {
   const days = options.days ?? 30;
-  const response = await sendCommand({
-    id: generateId(),
-    action: "history",
-    historyCommand: "domains",
-    ms: days
-  });
-  if (!response.success) {
-    throw new Error(response.error || "History command failed");
-  }
-  const historyDomains = response.data?.historyDomains || [];
+  const historyDomains = getHistoryDomains(days);
   const sites = getAllSites();
   const sitesByDomain = /* @__PURE__ */ new Map();
   for (const site of sites) {
@@ -593,7 +1440,7 @@ async function siteRun(name, args, options) {
       process.exit(1);
     }
   }
-  const jsContent = readFileSync(site.filePath, "utf-8");
+  const jsContent = readFileSync2(site.filePath, "utf-8");
   const jsBody = jsContent.replace(/\/\*\s*@meta[\s\S]*?\*\//, "").trim();
   const argsJson = JSON.stringify(argMap);
   const script = `(${jsBody})(${argsJson})`;
@@ -653,7 +1500,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 sendCommand(listReq);
+    const listResp = await sendCommand2(listReq);
     if (listResp.success && listResp.data?.tabs) {
       const matchingTab = listResp.data.tabs.find(
         (tab) => matchTabOrigin(tab.url, site.domain)
@@ -663,7 +1510,7 @@ async function siteRun(name, args, options) {
       }
     }
     if (!targetTabId) {
-      const newResp = await sendCommand({
+      const newResp = await sendCommand2({
         id: generateId(),
         action: "tab_new",
         url: `https://${site.domain}`
@@ -673,7 +1520,7 @@ async function siteRun(name, args, options) {
     }
   }
   const evalReq = { id: generateId(), action: "eval", script, tabId: targetTabId };
-  const evalResp = await sendCommand(evalReq);
+  const evalResp = await sendCommand2(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) {
@@ -808,10 +1655,10 @@ async function siteCommand(args, options = {}) {
   silentUpdate();
 }
 function silentUpdate() {
-  const gitDir = join(COMMUNITY_SITES_DIR, ".git");
-  if (!existsSync2(gitDir)) return;
-  import("child_process").then(({ spawn: spawn3 }) => {
-    const child = spawn3("git", ["pull", "--ff-only"], {
+  const gitDir = join2(COMMUNITY_SITES_DIR, ".git");
+  if (!existsSync4(gitDir)) return;
+  import("child_process").then(({ spawn: spawn2 }) => {
+    const child = spawn2("git", ["pull", "--ff-only"], {
       cwd: COMMUNITY_SITES_DIR,
       stdio: "ignore",
       detached: true
@@ -847,7 +1694,7 @@ async function openCommand(url, options = {}) {
       request.tabId = tabId;
     }
   }
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -883,7 +1730,7 @@ async function snapshotCommand(options = {}) {
     selector: options.selector,
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -902,7 +1749,7 @@ async function snapshotCommand(options = {}) {
 }
 
 // packages/cli/src/commands/click.ts
-function parseRef(ref) {
+function parseRef2(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function clickCommand(ref, options = {}) {
@@ -910,14 +1757,14 @@ async function clickCommand(ref, options = {}) {
     throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
   }
   await ensureDaemonRunning();
-  const parsedRef = parseRef(ref);
+  const parsedRef = parseRef2(ref);
   const request = {
     id: generateId(),
     action: "click",
     ref: parsedRef,
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -937,7 +1784,7 @@ async function clickCommand(ref, options = {}) {
 }
 
 // packages/cli/src/commands/hover.ts
-function parseRef2(ref) {
+function parseRef3(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function hoverCommand(ref, options = {}) {
@@ -945,14 +1792,14 @@ async function hoverCommand(ref, options = {}) {
     throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
   }
   await ensureDaemonRunning();
-  const parsedRef = parseRef2(ref);
+  const parsedRef = parseRef3(ref);
   const request = {
     id: generateId(),
     action: "hover",
     ref: parsedRef,
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -972,7 +1819,7 @@ async function hoverCommand(ref, options = {}) {
 }
 
 // packages/cli/src/commands/fill.ts
-function parseRef3(ref) {
+function parseRef4(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function fillCommand(ref, text, options = {}) {
@@ -983,7 +1830,7 @@ async function fillCommand(ref, text, options = {}) {
     throw new Error("\u7F3A\u5C11 text \u53C2\u6570");
   }
   await ensureDaemonRunning();
-  const parsedRef = parseRef3(ref);
+  const parsedRef = parseRef4(ref);
   const request = {
     id: generateId(),
     action: "fill",
@@ -991,7 +1838,7 @@ async function fillCommand(ref, text, options = {}) {
     text,
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1012,7 +1859,7 @@ async function fillCommand(ref, text, options = {}) {
 }
 
 // packages/cli/src/commands/type.ts
-function parseRef4(ref) {
+function parseRef5(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function typeCommand(ref, text, options = {}) {
@@ -1023,7 +1870,7 @@ async function typeCommand(ref, text, options = {}) {
     throw new Error("\u7F3A\u5C11 text \u53C2\u6570");
   }
   await ensureDaemonRunning();
-  const parsedRef = parseRef4(ref);
+  const parsedRef = parseRef5(ref);
   const request = {
     id: generateId(),
     action: "type",
@@ -1031,7 +1878,7 @@ async function typeCommand(ref, text, options = {}) {
     text,
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1059,7 +1906,7 @@ async function closeCommand(options = {}) {
     action: "close",
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1078,7 +1925,7 @@ async function closeCommand(options = {}) {
 }
 
 // packages/cli/src/commands/get.ts
-function parseRef5(ref) {
+function parseRef6(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function getCommand(attribute, ref, options = {}) {
@@ -1090,10 +1937,10 @@ async function getCommand(attribute, ref, options = {}) {
     id: generateId(),
     action: "get",
     attribute,
-    ref: ref ? parseRef5(ref) : void 0,
+    ref: ref ? parseRef6(ref) : void 0,
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1109,17 +1956,17 @@ async function getCommand(attribute, ref, options = {}) {
 
 // packages/cli/src/commands/screenshot.ts
 import fs from "fs";
-import path from "path";
-import os from "os";
+import path3 from "path";
+import os2 from "os";
 function getDefaultPath() {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const filename = `bb-screenshot-${timestamp}.png`;
-  return path.join(os.tmpdir(), filename);
+  return path3.join(os2.tmpdir(), filename);
 }
 function saveBase64Image(dataUrl, filePath) {
   const base64Data = dataUrl.replace(/^data:image\/png;base64,/, "");
   const buffer = Buffer.from(base64Data, "base64");
-  const dir = path.dirname(filePath);
+  const dir = path3.dirname(filePath);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
@@ -1127,13 +1974,13 @@ function saveBase64Image(dataUrl, filePath) {
 }
 async function screenshotCommand(outputPath, options = {}) {
   await ensureDaemonRunning();
-  const filePath = outputPath ? path.resolve(outputPath) : getDefaultPath();
+  const filePath = outputPath ? path3.resolve(outputPath) : getDefaultPath();
   const request = {
     id: generateId(),
     action: "screenshot",
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (response.success && response.data?.dataUrl) {
     const dataUrl = response.data.dataUrl;
     saveBase64Image(dataUrl, filePath);
@@ -1160,7 +2007,7 @@ async function screenshotCommand(outputPath, options = {}) {
 function isTimeWait(target) {
   return /^\d+$/.test(target);
 }
-function parseRef6(ref) {
+function parseRef7(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function waitCommand(target, options = {}) {
@@ -1179,7 +2026,7 @@ async function waitCommand(target, options = {}) {
       tabId: options.tabId
     };
   } else {
-    const ref = parseRef6(target);
+    const ref = parseRef7(target);
     request = {
       id: generateId(),
       action: "wait",
@@ -1188,7 +2035,7 @@ async function waitCommand(target, options = {}) {
       tabId: options.tabId
     };
   }
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1196,7 +2043,7 @@ async function waitCommand(target, options = {}) {
       if (isTimeWait(target)) {
         console.log(`\u5DF2\u7B49\u5F85 ${target}ms`);
       } else {
-        console.log(`\u5143\u7D20 @${parseRef6(target)} \u5DF2\u51FA\u73B0`);
+        console.log(`\u5143\u7D20 @${parseRef7(target)} \u5DF2\u51FA\u73B0`);
       }
     } else {
       console.error(`\u9519\u8BEF: ${response.error}`);
@@ -1236,7 +2083,7 @@ async function pressCommand(keyString, options = {}) {
     modifiers,
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1277,7 +2124,7 @@ async function scrollCommand(direction, pixels, options = {}) {
     pixels: pixelValue,
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1291,76 +2138,17 @@ async function scrollCommand(direction, pixels, options = {}) {
 }
 
 // packages/cli/src/commands/daemon.ts
-import { spawn as spawn2 } from "child_process";
-async function daemonCommand(options = {}) {
-  if (await isDaemonRunning()) {
-    if (options.json) {
-      console.log(JSON.stringify({ success: false, error: "Daemon \u5DF2\u5728\u8FD0\u884C" }));
-    } else {
-      console.log("Daemon \u5DF2\u5728\u8FD0\u884C");
-    }
-    return;
-  }
-  const daemonPath = getDaemonPath();
-  const args = [daemonPath];
-  if (options.host) {
-    args.push("--host", options.host);
-  }
-  if (options.json) {
-    console.log(JSON.stringify({ success: true, message: "Daemon \u542F\u52A8\u4E2D..." }));
-  } else {
-    console.log("Daemon \u542F\u52A8\u4E2D...");
-  }
-  await new Promise((resolve2, reject) => {
-    const child = spawn2(process.execPath, args, {
-      stdio: "inherit"
-    });
-    child.on("exit", (code) => {
-      if (code && code !== 0) {
-        reject(new Error(`Daemon exited with code ${code}`));
-      } else {
-        resolve2();
-      }
-    });
-    child.on("error", reject);
-  });
-}
-async function stopCommand(options = {}) {
-  if (!await isDaemonRunning()) {
-    if (options.json) {
-      console.log(JSON.stringify({ success: false, error: "Daemon \u672A\u8FD0\u884C" }));
-    } else {
-      console.log("Daemon \u672A\u8FD0\u884C");
-    }
-    return;
-  }
-  const stopped = await stopDaemon();
-  if (stopped) {
-    if (options.json) {
-      console.log(JSON.stringify({ success: true, message: "Daemon \u5DF2\u505C\u6B62" }));
-    } else {
-      console.log("Daemon \u5DF2\u505C\u6B62");
-    }
-  } else {
-    if (options.json) {
-      console.log(JSON.stringify({ success: false, error: "\u65E0\u6CD5\u505C\u6B62 Daemon" }));
-    } else {
-      console.error("\u65E0\u6CD5\u505C\u6B62 Daemon");
-    }
-    process.exit(1);
-  }
-}
 async function statusCommand(options = {}) {
   const running = await isDaemonRunning();
   if (options.json) {
     console.log(JSON.stringify({ running }));
   } else {
-    console.log(running ? "Daemon \u8FD0\u884C\u4E2D" : "Daemon \u672A\u8FD0\u884C");
+    console.log(running ? "\u6D4F\u89C8\u5668\u8FD0\u884C\u4E2D" : "\u6D4F\u89C8\u5668\u672A\u8FD0\u884C");
   }
 }
 
 // packages/cli/src/commands/reload.ts
-import WebSocket from "ws";
+import WebSocket2 from "ws";
 var EXTENSION_NAME = "bb-browser";
 async function reloadCommand(options = {}) {
   const port = options.port || 9222;
@@ -1377,7 +2165,7 @@ async function reloadCommand(options = {}) {
       throw new Error("\u8BF7\u5148\u6253\u5F00 chrome://extensions \u9875\u9762");
     }
     const result = await new Promise((resolve2, reject) => {
-      const ws = new WebSocket(extPage.webSocketDebuggerUrl);
+      const ws = new WebSocket2(extPage.webSocketDebuggerUrl);
       let resolved = false;
       const timeout = setTimeout(() => {
         if (!resolved) {
@@ -1474,7 +2262,7 @@ async function backCommand(options = {}) {
     action: "back",
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1498,7 +2286,7 @@ async function forwardCommand(options = {}) {
     action: "forward",
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1522,7 +2310,7 @@ async function refreshCommand(options = {}) {
     action: "refresh",
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1541,7 +2329,7 @@ async function refreshCommand(options = {}) {
 }
 
 // packages/cli/src/commands/check.ts
-function parseRef7(ref) {
+function parseRef8(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function checkCommand(ref, options = {}) {
@@ -1549,14 +2337,14 @@ async function checkCommand(ref, options = {}) {
     throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
   }
   await ensureDaemonRunning();
-  const parsedRef = parseRef7(ref);
+  const parsedRef = parseRef8(ref);
   const request = {
     id: generateId(),
     action: "check",
     ref: parsedRef,
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1588,14 +2376,14 @@ async function uncheckCommand(ref, options = {}) {
     throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
   }
   await ensureDaemonRunning();
-  const parsedRef = parseRef7(ref);
+  const parsedRef = parseRef8(ref);
   const request = {
     id: generateId(),
     action: "uncheck",
     ref: parsedRef,
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1624,7 +2412,7 @@ async function uncheckCommand(ref, options = {}) {
 }
 
 // packages/cli/src/commands/select.ts
-function parseRef8(ref) {
+function parseRef9(ref) {
   return ref.startsWith("@") ? ref.slice(1) : ref;
 }
 async function selectCommand(ref, value, options = {}) {
@@ -1635,7 +2423,7 @@ async function selectCommand(ref, value, options = {}) {
     throw new Error("\u7F3A\u5C11 value \u53C2\u6570");
   }
   await ensureDaemonRunning();
-  const parsedRef = parseRef8(ref);
+  const parsedRef = parseRef9(ref);
   const request = {
     id: generateId(),
     action: "select",
@@ -1643,7 +2431,7 @@ async function selectCommand(ref, value, options = {}) {
     value,
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1681,7 +2469,7 @@ async function evalCommand(script, options = {}) {
     script,
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1768,7 +2556,7 @@ async function tabCommand(args, options = {}) {
     index: parsed.index,
     tabId: parsed.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1817,7 +2605,7 @@ async function frameCommand(selector, options = {}) {
     selector,
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1841,7 +2629,7 @@ async function frameMainCommand(options = {}) {
     action: "frame_main",
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1867,7 +2655,7 @@ async function dialogCommand(subCommand, promptText, options = {}) {
     promptText: subCommand === "accept" ? promptText : void 0,
     tabId: options.tabId
   };
-  const response = await sendCommand(request);
+  const response = await sendCommand2(request);
   if (options.json) {
     console.log(JSON.stringify(response, null, 2));
   } else {
@@ -1888,7 +2676,7 @@ async function dialogCommand(subCommand, promptText, options = {}) {
 
 // packages/cli/src/commands/network.ts
 async function networkCommand(subCommand, urlOrFilter, options = {}) {
-  const response = await sendCommand({
+  const response = await sendCommand2({
     id: crypto.randomUUID(),
     action: "network",
     networkCommand: subCommand,
@@ -1975,7 +2763,7 @@ async function networkCommand(subCommand, urlOrFilter, options = {}) {
 
 // packages/cli/src/commands/console.ts
 async function consoleCommand(options = {}) {
-  const response = await sendCommand({
+  const response = await sendCommand2({
     id: crypto.randomUUID(),
     action: "console",
     consoleCommand: options.clear ? "clear" : "get",
@@ -2020,7 +2808,7 @@ async function consoleCommand(options = {}) {
 
 // packages/cli/src/commands/errors.ts
 async function errorsCommand(options = {}) {
-  const response = await sendCommand({
+  const response = await sendCommand2({
     id: crypto.randomUUID(),
     action: "errors",
     errorsCommand: options.clear ? "clear" : "get",
@@ -2060,7 +2848,7 @@ async function errorsCommand(options = {}) {
 
 // packages/cli/src/commands/trace.ts
 async function traceCommand(subCommand, options = {}) {
-  const response = await sendCommand({
+  const response = await sendCommand2({
     id: crypto.randomUUID(),
     action: "trace",
     traceCommand: subCommand,
@@ -2150,7 +2938,7 @@ function matchTabOrigin2(tabUrl, targetHostname) {
 }
 async function ensureTabForOrigin(origin, hostname) {
   const listReq = { id: generateId(), action: "tab_list" };
-  const listResp = await sendCommand(listReq);
+  const listResp = await sendCommand2(listReq);
   if (listResp.success && listResp.data?.tabs) {
     const matchingTab = listResp.data.tabs.find(
       (tab) => matchTabOrigin2(tab.url, hostname)
@@ -2159,7 +2947,7 @@ async function ensureTabForOrigin(origin, hostname) {
       return matchingTab.tabId;
     }
   }
-  const newResp = await sendCommand({ id: generateId(), action: "tab_new", url: origin });
+  const newResp = await sendCommand2({ id: generateId(), action: "tab_new", url: origin });
   if (!newResp.success) {
     throw new Error(`\u65E0\u6CD5\u6253\u5F00 ${origin}: ${newResp.error}`);
   }
@@ -2228,7 +3016,7 @@ async function fetchCommand(url, options = {}) {
   }
   const script = buildFetchScript(url, options);
   const evalReq = { id: generateId(), action: "eval", script, tabId: targetTabId };
-  const evalResp = await sendCommand(evalReq);
+  const evalResp = await sendCommand2(evalReq);
   if (!evalResp.success) {
     throw new Error(`Fetch \u5931\u8D25: ${evalResp.error}`);
   }
@@ -2262,21 +3050,16 @@ async function fetchCommand(url, options = {}) {
 
 // packages/cli/src/commands/history.ts
 async function historyCommand(subCommand, options = {}) {
-  const response = await sendCommand({
-    id: crypto.randomUUID(),
-    action: "history",
-    historyCommand: subCommand,
-    text: options.query,
-    ms: options.days
-  });
+  const days = options.days || 30;
+  const data = subCommand === "search" ? { historyItems: searchHistory(options.query, days) } : { historyDomains: getHistoryDomains(days) };
   if (options.json) {
-    console.log(JSON.stringify(response));
+    console.log(JSON.stringify({
+      id: crypto.randomUUID(),
+      success: true,
+      data
+    }));
     return;
   }
-  if (!response.success) {
-    throw new Error(response.error || "History command failed");
-  }
-  const data = response.data;
   switch (subCommand) {
     case "search": {
       const items = data?.historyItems || [];
@@ -2315,10 +3098,13 @@ async function historyCommand(subCommand, options = {}) {
 }
 
 // packages/cli/src/index.ts
-var VERSION = "0.7.0";
+var VERSION = "0.8.0";
 var HELP_TEXT = `
 bb-browser - AI Agent \u6D4F\u89C8\u5668\u81EA\u52A8\u5316\u5DE5\u5177
 
+\u5B89\u88C5\uFF1A
+  npm install -g bb-browser
+
 \u63D0\u793A\uFF1A\u5927\u591A\u6570\u6570\u636E\u83B7\u53D6\u4EFB\u52A1\u8BF7\u76F4\u63A5\u4F7F\u7528 site \u547D\u4EE4\uFF0C\u65E0\u9700\u624B\u52A8\u64CD\u4F5C\u6D4F\u89C8\u5668\uFF1A
   bb-browser site list                    \u67E5\u770B\u6240\u6709\u53EF\u7528\u547D\u4EE4
   bb-browser site twitter/search "AI"     \u793A\u4F8B\uFF1A\u641C\u7D22\u63A8\u6587
@@ -2356,6 +3142,7 @@ bb-browser - AI Agent \u6D4F\u89C8\u5668\u81EA\u52A8\u5316\u5DE5\u5177
 
 \u6807\u7B7E\u9875\uFF1A
   tab [list|new|close|<n>]     \u7BA1\u7406\u6807\u7B7E\u9875
+  status                       \u67E5\u770B\u53D7\u7BA1\u6D4F\u89C8\u5668\u72B6\u6001
 
 \u5BFC\u822A\uFF1A
   back / forward / refresh     \u540E\u9000 / \u524D\u8FDB / \u5237\u65B0
@@ -2369,6 +3156,8 @@ bb-browser - AI Agent \u6D4F\u89C8\u5668\u81EA\u52A8\u5316\u5DE5\u5177
 
 \u9009\u9879\uFF1A
   --json               \u4EE5 JSON \u683C\u5F0F\u8F93\u51FA
+  --port <n>           \u6307\u5B9A Chrome CDP \u7AEF\u53E3
+  --openclaw           \u4F18\u5148\u590D\u7528 OpenClaw \u6D4F\u89C8\u5668\u5B9E\u4F8B
   --jq <expr>          \u5BF9 JSON \u8F93\u51FA\u5E94\u7528 jq \u8FC7\u6EE4\uFF08\u76F4\u63A5\u4F5C\u7528\u4E8E\u6570\u636E\uFF0C\u8DF3\u8FC7 id/success \u4FE1\u5C01\uFF09
   -i, --interactive    \u53EA\u8F93\u51FA\u53EF\u4EA4\u4E92\u5143\u7D20\uFF08snapshot \u547D\u4EE4\uFF09
   -c, --compact        \u79FB\u9664\u7A7A\u7ED3\u6784\u8282\u70B9\uFF08snapshot \u547D\u4EE4\uFF09
@@ -2409,6 +3198,12 @@ function parseArgs(argv) {
       }
     } else if (arg === "--openclaw") {
       result.flags.openclaw = true;
+    } else if (arg === "--port") {
+      skipNext = true;
+      const nextIdx = args.indexOf(arg) + 1;
+      if (nextIdx < args.length) {
+        result.flags.port = parseInt(args[nextIdx], 10);
+      }
     } else if (arg === "--help" || arg === "-h") {
       result.flags.help = true;
     } else if (arg === "--version" || arg === "-v") {
@@ -2458,9 +3253,9 @@ async function main() {
     return;
   }
   if (process.argv.includes("--mcp")) {
-    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" });
+    const mcpPath = fileURLToPath3(new URL("./mcp.js", import.meta.url));
+    const { spawn: spawn2 } = await import("child_process");
+    const child = spawn2(process.execPath, [mcpPath], { stdio: "inherit" });
     child.on("exit", (code) => process.exit(code ?? 0));
     return;
   }
@@ -2818,9 +3613,9 @@ async function main() {
         break;
       }
       case "star": {
-        const { execSync: execSync2 } = await import("child_process");
+        const { execSync: execSync4 } = await import("child_process");
         try {
-          execSync2("gh auth status", { stdio: "pipe" });
+          execSync4("gh auth status", { stdio: "pipe" });
         } catch {
           console.error("\u9700\u8981\u5148\u5B89\u88C5\u5E76\u767B\u5F55 GitHub CLI: https://cli.github.com");
           console.error("  brew install gh && gh auth login");
@@ -2829,7 +3624,7 @@ async function main() {
         const repos = ["epiral/bb-browser", "epiral/bb-sites"];
         for (const repo of repos) {
           try {
-            execSync2(`gh api user/starred/${repo} -X PUT`, { stdio: "pipe" });
+            execSync4(`gh api user/starred/${repo} -X PUT`, { stdio: "pipe" });
             console.log(`\u2B50 Starred ${repo}`);
           } catch {
             console.log(`Already starred or failed: ${repo}`);