bb-browser 0.8.2 → 0.9.0

package/dist/cli.js

@@ -6,10 +6,13 @@ import {
 import {
   applyJq
 } from "./chunk-AHGAQEFO.js";
+import {
+  parseOpenClawJson
+} from "./chunk-FSL4RNI6.js";
 import "./chunk-D4HDZEJT.js";
 
 // packages/cli/src/index.ts
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
 
 // packages/cli/src/cdp-client.ts
 import { readFileSync, unlinkSync, writeFileSync } from "fs";
@@ -31,13 +34,13 @@ 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) => {
+  return new Promise((resolve3, reject) => {
     execFile(command, args, { encoding: "utf8", timeout }, (error, stdout) => {
       if (error) {
         reject(error);
         return;
       }
-      resolve2(stdout.trim());
+      resolve3(stdout.trim());
     });
   });
 }
@@ -49,7 +52,7 @@ function getArgValue(flag) {
 async function tryOpenClaw() {
   try {
     const raw = await execFileAsync("npx", ["openclaw", "browser", "status", "--json"], 5e3);
-    const parsed = JSON.parse(raw);
+    const parsed = parseOpenClawJson(raw);
     const port = Number(parsed?.cdpPort);
     if (Number.isInteger(port) && port > 0) {
       return { host: "127.0.0.1", port };
@@ -73,6 +76,10 @@ function findBrowserExecutable() {
   if (process.platform === "darwin") {
     const candidates = [
       "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Applications/Google Chrome Dev.app/Contents/MacOS/Google Chrome Dev",
+      "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+      "/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta",
+      "/Applications/Arc.app/Contents/MacOS/Arc",
       "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
       "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
     ];
@@ -101,6 +108,18 @@ 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) {
@@ -151,7 +170,7 @@ 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((resolve2) => setTimeout(resolve2, 250));
+    await new Promise((resolve3) => setTimeout(resolve3, 250));
   }
   return null;
 }
@@ -198,11 +217,35 @@ 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((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const requester = url.startsWith("https:") ? httpsRequest : httpRequest;
     const req = requester(url, { method: "GET" }, (res) => {
       const chunks = [];
@@ -214,7 +257,7 @@ function fetchJson(url) {
           return;
         }
         try {
-          resolve2(JSON.parse(raw));
+          resolve3(JSON.parse(raw));
         } catch (error) {
           reject(error);
         }
@@ -237,14 +280,14 @@ async function getJsonVersion(host, port) {
   return { webSocketDebuggerUrl: url };
 }
 function connectWebSocket(url) {
-  return new Promise((resolve2, reject) => {
+  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();
       }
-      resolve2(ws);
+      resolve3(ws);
     });
     ws.once("error", reject);
   });
@@ -260,6 +303,7 @@ function createState(host, port, browserWsUrl, browserSocket) {
     sessions: /* @__PURE__ */ new Map(),
     attachedTargets: /* @__PURE__ */ new Map(),
     refsByTarget: /* @__PURE__ */ new Map(),
+    currentTargetId: loadPersistedCurrentTargetId(host, port),
     activeFrameIdByTarget: /* @__PURE__ */ new Map(),
     dialogHandlers: /* @__PURE__ */ new Map()
   };
@@ -296,6 +340,10 @@ function createState(host, port, browserWsUrl, browserSocket) {
           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;
@@ -339,8 +387,8 @@ async function browserCommand(method, params = {}) {
   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 });
+  const promise = new Promise((resolve3, reject) => {
+    state.browserPending.set(id, { resolve: resolve3, reject, method });
   });
   state.browserSocket.send(payload);
   return promise;
@@ -351,13 +399,13 @@ async function sessionCommand(targetId, method, params = {}) {
   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) => {
+  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 resolve2(msg.result);
+        else resolve3(msg.result);
       }
     };
     state.browserSocket.on("message", check);
@@ -508,6 +556,7 @@ async function getTargets() {
 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);
@@ -519,9 +568,11 @@ async function ensurePageTarget(targetId) {
         target = targets[numericTargetId] ?? targets.find((item) => Number(item.id) === numericTargetId);
       }
     }
+  } else if (persistedTargetId) {
+    target = targets.find((item) => item.id === persistedTargetId);
   }
   target ??= targets[0];
-  connectionState.currentTargetId = target.id;
+  setCurrentTargetId(target.id);
   await attachTarget(target.id);
   return target;
 }
@@ -638,19 +689,16 @@ async function evaluate(targetId, expression, returnByValue = true) {
   const result = await sessionCommand(targetId, "Runtime.evaluate", {
     expression,
     awaitPromise: true,
-    returnByValue
+    returnByValue,
+    replMode: true
   });
   if (result.exceptionDetails) {
-    throw new Error(result.exceptionDetails.text || "Runtime.evaluate failed");
+    throw new Error(
+      result.exceptionDetails.exception?.description || 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) {
   await sessionCommand(targetId, "DOM.focus", { backendNodeId });
 }
@@ -658,40 +706,77 @@ async function insertTextIntoNode(targetId, backendNodeId, text, clearFirst) {
   const resolved = await sessionCommand(targetId, "DOM.resolveNode", { backendNodeId });
   await sessionCommand(targetId, "Runtime.callFunctionOn", {
     objectId: resolved.object.objectId,
-    functionDeclaration: `function(value, clearFirst) {
+    functionDeclaration: `function(clearFirst) {
+      if (typeof this.scrollIntoView === 'function') {
+        this.scrollIntoView({ behavior: 'auto', block: 'center', inline: 'center' });
+      }
       if (typeof this.focus === 'function') this.focus();
-      if (clearFirst && ('value' in this)) {
-        this.value = '';
-        this.dispatchEvent(new Event('input', { bubbles: true }));
-      }
-      if ('value' in this) {
-        this.value = clearFirst ? value : String(this.value ?? '') + value;
-        this.dispatchEvent(new Event('input', { bubbles: true }));
-        this.dispatchEvent(new Event('change', { bubbles: true }));
+      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: text },
       { value: clearFirst }
     ],
     returnByValue: true
   });
-  await focusNode(targetId, backendNodeId);
-  await sessionCommand(targetId, "Input.insertText", { text });
+  if (text) {
+    await focusNode(targetId, backendNodeId);
+    await sessionCommand(targetId, "Input.insertText", { text });
+  }
 }
-async function getNodeBox(targetId, backendNodeId) {
-  const result = await sessionCommand(targetId, "DOM.getBoxModel", {
-    backendNodeId
+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
   });
-  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
-  };
+  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" });
@@ -699,9 +784,14 @@ async function mouseClick(targetId, x, y) {
   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 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", {
@@ -929,7 +1019,7 @@ async function dispatchRequest(request) {
     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 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 });
       }
@@ -946,7 +1036,7 @@ async function dispatchRequest(request) {
     case "hover": {
       if (!request.ref) return fail(request.id, "Missing ref parameter");
       const backendNodeId = await parseRef(request.ref);
-      const point = await getNodeBox(target.id, backendNodeId);
+      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, {});
@@ -982,7 +1072,14 @@ async function dispatchRequest(request) {
       return ok(request.id, { value: request.value });
     }
     case "get": {
-      if (!request.ref || !request.attribute) return fail(request.id, "Missing ref or attribute parameter");
+      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 });
     }
@@ -997,7 +1094,7 @@ async function dispatchRequest(request) {
       return ok(request.id, {});
     }
     case "wait": {
-      await new Promise((resolve2) => setTimeout(resolve2, request.ms ?? 1e3));
+      await new Promise((resolve3) => setTimeout(resolve3, request.ms ?? 1e3));
       return ok(request.id, {});
     }
     case "press": {
@@ -1036,14 +1133,14 @@ async function dispatchRequest(request) {
       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" });
+      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");
-      connectionState.currentTargetId = selected.id;
+      setCurrentTargetId(selected.id);
       await attachTarget(selected.id);
       return ok(request.id, { tabId: selected.id, url: selected.url, title: selected.title });
     }
@@ -1053,6 +1150,9 @@ async function dispatchRequest(request) {
       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 });
     }
@@ -1160,7 +1260,167 @@ async function dispatchRequest(request) {
   }
 }
 
+// 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);
+    const payload = body !== void 0 ? JSON.stringify(body) : void 0;
+    const req = httpRequest2(
+      {
+        hostname: parsed.hostname,
+        port: parsed.port,
+        path: parsed.pathname,
+        method,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          ...payload ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) } : {}
+        },
+        timeout: 5e3
+      },
+      (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(`Monitor HTTP ${res.statusCode}: ${raw}`));
+            return;
+          }
+          try {
+            resolve3(JSON.parse(raw));
+          } catch {
+            reject(new Error(`Invalid JSON from monitor: ${raw}`));
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Monitor request timed out"));
+    });
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+async function readPortFile() {
+  try {
+    const raw = await readFile2(PORT_FILE, "utf8");
+    const port = Number.parseInt(raw.trim(), 10);
+    return Number.isInteger(port) && port > 0 ? port : null;
+  } catch {
+    return null;
+  }
+}
+async function readTokenFile() {
+  try {
+    return (await readFile2(TOKEN_FILE, "utf8")).trim();
+  } catch {
+    return null;
+  }
+}
+async function ensureMonitorRunning() {
+  const existingPort = await readPortFile();
+  const existingToken = await readTokenFile();
+  if (existingPort && existingToken) {
+    try {
+      const status = await httpJson(
+        "GET",
+        `http://127.0.0.1:${existingPort}/status`,
+        existingToken
+      );
+      if (status.running) {
+        return { port: existingPort, token: existingToken };
+      }
+    } catch {
+    }
+  }
+  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
+  ], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 200));
+    try {
+      const status = await httpJson(
+        "GET",
+        `http://127.0.0.1:${monitorPort}/status`,
+        token
+      );
+      if (status.running) {
+        return { port: monitorPort, token };
+      }
+    } 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
+  );
+}
+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;
+    }
+  }
+  return candidates[0];
+}
+
 // packages/cli/src/client.ts
+var MONITOR_ACTIONS = /* @__PURE__ */ new Set(["network", "console", "errors", "trace"]);
 var jqExpression;
 function setJqExpression(expression) {
   jqExpression = expression;
@@ -1179,15 +1439,22 @@ function handleJqResponse(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 fileURLToPath2 } from "url";
-import { dirname, resolve } from "path";
-import { existsSync as existsSync2 } from "fs";
+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 discoverCdpPort() !== null;
+  return await isManagedBrowserRunning();
 }
 async function ensureDaemonRunning() {
   try {
@@ -1206,7 +1473,7 @@ async function ensureDaemonRunning() {
 }
 
 // packages/cli/src/history-sqlite.ts
-import { copyFileSync, existsSync as existsSync3, unlinkSync as unlinkSync2 } from "fs";
+import { copyFileSync, existsSync as existsSync4, unlinkSync as unlinkSync2 } from "fs";
 import { execSync as execSync2 } from "child_process";
 import { homedir, tmpdir } from "os";
 import { join } from "path";
@@ -1230,7 +1497,7 @@ function getHistoryPathCandidates() {
 }
 function findHistoryPath() {
   for (const historyPath of getHistoryPathCandidates()) {
-    if (existsSync3(historyPath)) {
+    if (existsSync4(historyPath)) {
       return historyPath;
     }
   }
@@ -1350,7 +1617,7 @@ function getHistoryDomains(days) {
 }
 
 // packages/cli/src/commands/site.ts
-import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync4, mkdirSync } from "fs";
+import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync5, mkdirSync } from "fs";
 import { join as join2, relative } from "path";
 import { homedir as homedir2 } from "os";
 import { execSync as execSync3 } from "child_process";
@@ -1369,6 +1636,10 @@ function checkCliUpdate() {
   } catch {
   }
 }
+function exitJsonError(error, extra = {}) {
+  console.log(JSON.stringify({ success: false, error, ...extra }, null, 2));
+  process.exit(1);
+}
 function parseSiteMeta(filePath, source) {
   let content;
   try {
@@ -1432,7 +1703,7 @@ function parseSiteMeta(filePath, source) {
   return meta;
 }
 function scanSites(dir, source) {
-  if (!existsSync4(dir)) return [];
+  if (!existsSync5(dir)) return [];
   const sites = [];
   function walk(currentDir) {
     let entries;
@@ -1486,6 +1757,10 @@ function matchTabOrigin(tabUrl, domain) {
 function siteList(options) {
   const sites = getAllSites();
   if (sites.length === 0) {
+    if (options.json) {
+      console.log("[]");
+      return;
+    }
     console.log("\u672A\u627E\u5230\u4EFB\u4F55 site adapter\u3002");
     console.log("  \u5B89\u88C5\u793E\u533A adapter: bb-browser site update");
     console.log(`  \u79C1\u6709 adapter \u76EE\u5F55: ${LOCAL_SITES_DIR}`);
@@ -1526,6 +1801,10 @@ function siteSearch(query, options) {
     (s) => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q) || s.domain.toLowerCase().includes(q)
   );
   if (matches.length === 0) {
+    if (options.json) {
+      console.log("[]");
+      return;
+    }
     console.log(`\u672A\u627E\u5230\u5339\u914D "${query}" \u7684 adapter\u3002`);
     console.log("  \u67E5\u770B\u6240\u6709: bb-browser site list");
     return;
@@ -1544,34 +1823,63 @@ function siteSearch(query, options) {
     console.log(`${s.name.padEnd(24)} ${s.description}${src}`);
   }
 }
-function siteUpdate() {
+function siteUpdate(options = {}) {
   mkdirSync(BB_DIR, { recursive: true });
-  if (existsSync4(join2(COMMUNITY_SITES_DIR, ".git"))) {
-    console.log("\u66F4\u65B0\u793E\u533A site adapter \u5E93...");
+  const updateMode = existsSync5(join2(COMMUNITY_SITES_DIR, ".git")) ? "pull" : "clone";
+  if (updateMode === "pull") {
+    if (!options.json) {
+      console.log("\u66F4\u65B0\u793E\u533A site adapter \u5E93...");
+    }
     try {
       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");
+      if (!options.json) {
+        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");
+      }
     } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      const manualAction = "cd ~/.bb-browser/bb-sites && git pull";
+      if (options.json) {
+        exitJsonError(`\u66F4\u65B0\u5931\u8D25: ${message}`, { action: manualAction, updateMode });
+      }
       console.error(`\u66F4\u65B0\u5931\u8D25: ${e instanceof Error ? e.message : e}`);
       console.error("  \u624B\u52A8\u4FEE\u590D: cd ~/.bb-browser/bb-sites && git pull");
       process.exit(1);
     }
   } else {
-    console.log(`\u514B\u9686\u793E\u533A adapter \u5E93: ${COMMUNITY_REPO}`);
+    if (!options.json) {
+      console.log(`\u514B\u9686\u793E\u533A adapter \u5E93: ${COMMUNITY_REPO}`);
+    }
     try {
       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");
+      if (!options.json) {
+        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");
+      }
     } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      const manualAction = `git clone ${COMMUNITY_REPO} ~/.bb-browser/bb-sites`;
+      if (options.json) {
+        exitJsonError(`\u514B\u9686\u5931\u8D25: ${message}`, { action: manualAction, updateMode });
+      }
       console.error(`\u514B\u9686\u5931\u8D25: ${e instanceof Error ? e.message : e}`);
       console.error(`  \u624B\u52A8\u4FEE\u590D: git clone ${COMMUNITY_REPO} ~/.bb-browser/bb-sites`);
       process.exit(1);
     }
   }
   const sites = scanSites(COMMUNITY_SITES_DIR, "community");
+  if (options.json) {
+    console.log(JSON.stringify({
+      success: true,
+      updateMode,
+      communityRepo: COMMUNITY_REPO,
+      communityDir: COMMUNITY_SITES_DIR,
+      siteCount: sites.length
+    }, null, 2));
+    return;
+  }
   console.log(`\u5DF2\u5B89\u88C5 ${sites.length} \u4E2A\u793E\u533A adapter\u3002`);
   console.log(`\u2B50 Like bb-browser? \u2192 bb-browser star`);
   checkCliUpdate();
@@ -1582,6 +1890,9 @@ function findSiteByName(name) {
 function siteInfo(name, options) {
   const site = findSiteByName(name);
   if (!site) {
+    if (options.json) {
+      exitJsonError(`adapter "${name}" not found`, { action: "bb-browser site list" });
+    }
     console.error(`[error] site info: adapter "${name}" not found.`);
     console.error("  Try: bb-browser site list");
     process.exit(1);
@@ -1694,6 +2005,12 @@ async function siteRun(name, args, options) {
   const site = sites.find((s) => s.name === name);
   if (!site) {
     const fuzzy = sites.filter((s) => s.name.includes(name));
+    if (options.json) {
+      exitJsonError(`site "${name}" not found`, {
+        suggestions: fuzzy.slice(0, 5).map((s) => s.name),
+        action: fuzzy.length > 0 ? void 0 : "bb-browser site update"
+      });
+    }
     console.error(`[error] site: "${name}" not found.`);
     if (fuzzy.length > 0) {
       console.error("  Did you mean:");
@@ -1728,11 +2045,17 @@ async function siteRun(name, args, options) {
   }
   for (const [argName, argDef] of Object.entries(site.args)) {
     if (argDef.required && !argMap[argName]) {
-      console.error(`[error] site ${name}: missing required argument "${argName}".`);
       const usage = argNames.map((a) => {
         const def = site.args[a];
         return def.required ? `<${a}>` : `[${a}]`;
       }).join(" ");
+      if (options.json) {
+        exitJsonError(`missing required argument "${argName}"`, {
+          usage: `bb-browser site ${name} ${usage}`,
+          example: site.example
+        });
+      }
+      console.error(`[error] site ${name}: missing required argument "${argName}".`);
       console.error(`  Usage: bb-browser site ${name} ${usage}`);
       if (site.example) console.error(`  Example: ${site.example}`);
       process.exit(1);
@@ -1743,7 +2066,7 @@ async function siteRun(name, args, options) {
   const argsJson = JSON.stringify(argMap);
   const script = `(${jsBody})(${argsJson})`;
   if (options.openclaw) {
-    const { ocGetTabs, ocFindTabByDomain, ocOpenTab, ocEvaluate } = await import("./openclaw-bridge-P3G4KGYM.js");
+    const { ocGetTabs, ocFindTabByDomain, ocOpenTab, ocEvaluate } = await import("./openclaw-bridge-HBJH6UFO.js");
     let targetId;
     if (site.domain) {
       const tabs = ocGetTabs();
@@ -1752,7 +2075,7 @@ async function siteRun(name, args, options) {
         targetId = existing.targetId;
       } else {
         targetId = ocOpenTab(`https://${site.domain}`);
-        await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+        await new Promise((resolve3) => setTimeout(resolve3, 3e3));
       }
     } else {
       const tabs = ocGetTabs();
@@ -1814,7 +2137,7 @@ async function siteRun(name, args, options) {
         url: `https://${site.domain}`
       });
       targetTabId = newResp.data?.tabId;
-      await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+      await new Promise((resolve3) => setTimeout(resolve3, 3e3));
     }
   }
   const evalReq = { id: generateId(), action: "eval", script, tabId: targetTabId };
@@ -1928,7 +2251,7 @@ async function siteCommand(args, options = {}) {
       await siteRecommend(options);
       break;
     case "update":
-      siteUpdate();
+      siteUpdate(options);
       break;
     case "run":
       if (!args[1]) {
@@ -1954,9 +2277,9 @@ async function siteCommand(args, options = {}) {
 }
 function silentUpdate() {
   const gitDir = join2(COMMUNITY_SITES_DIR, ".git");
-  if (!existsSync4(gitDir)) return;
-  import("child_process").then(({ spawn: spawn2 }) => {
-    const child = spawn2("git", ["pull", "--ff-only"], {
+  if (!existsSync5(gitDir)) return;
+  import("child_process").then(({ spawn: spawn3 }) => {
+    const child = spawn3("git", ["pull", "--ff-only"], {
       cwd: COMMUNITY_SITES_DIR,
       stdio: "ignore",
       detached: true
@@ -2254,17 +2577,17 @@ async function getCommand(attribute, ref, options = {}) {
 
 // packages/cli/src/commands/screenshot.ts
 import fs from "fs";
-import path3 from "path";
-import os3 from "os";
+import path4 from "path";
+import os4 from "os";
 function getDefaultPath() {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const filename = `bb-screenshot-${timestamp}.png`;
-  return path3.join(os3.tmpdir(), filename);
+  return path4.join(os4.tmpdir(), filename);
 }
 function saveBase64Image(dataUrl, filePath) {
   const base64Data = dataUrl.replace(/^data:image\/png;base64,/, "");
   const buffer = Buffer.from(base64Data, "base64");
-  const dir = path3.dirname(filePath);
+  const dir = path4.dirname(filePath);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
@@ -2272,7 +2595,7 @@ function saveBase64Image(dataUrl, filePath) {
 }
 async function screenshotCommand(outputPath, options = {}) {
   await ensureDaemonRunning();
-  const filePath = outputPath ? path3.resolve(outputPath) : getDefaultPath();
+  const filePath = outputPath ? path4.resolve(outputPath) : getDefaultPath();
   const request = {
     id: generateId(),
     action: "screenshot",
@@ -2435,123 +2758,6 @@ async function scrollCommand(direction, pixels, options = {}) {
   }
 }
 
-// packages/cli/src/commands/daemon.ts
-async function statusCommand(options = {}) {
-  const running = await isDaemonRunning();
-  if (options.json) {
-    console.log(JSON.stringify({ running }));
-  } else {
-    console.log(running ? "\u6D4F\u89C8\u5668\u8FD0\u884C\u4E2D" : "\u6D4F\u89C8\u5668\u672A\u8FD0\u884C");
-  }
-}
-
-// packages/cli/src/commands/reload.ts
-import WebSocket2 from "ws";
-var EXTENSION_NAME = "bb-browser";
-async function reloadCommand(options = {}) {
-  const port = options.port || 9222;
-  try {
-    const listRes = await fetch(`http://127.0.0.1:${port}/json/list`);
-    if (!listRes.ok) {
-      throw new Error(`CDP \u672A\u542F\u7528\u3002\u8BF7\u7528 --remote-debugging-port=${port} \u542F\u52A8 Chrome`);
-    }
-    const list = await listRes.json();
-    const extPage = list.find(
-      (t) => t.type === "page" && t.url.includes("chrome://extensions")
-    );
-    if (!extPage) {
-      throw new Error("\u8BF7\u5148\u6253\u5F00 chrome://extensions \u9875\u9762");
-    }
-    const result = await new Promise((resolve2, reject) => {
-      const ws = new WebSocket2(extPage.webSocketDebuggerUrl);
-      let resolved = false;
-      const timeout = setTimeout(() => {
-        if (!resolved) {
-          resolved = true;
-          ws.close();
-          reject(new Error("CDP \u8FDE\u63A5\u8D85\u65F6"));
-        }
-      }, 1e4);
-      ws.on("open", () => {
-        const script = `
-          (async function() {
-            if (!chrome || !chrome.developerPrivate) {
-              return { error: 'developerPrivate API not available' };
-            }
-            
-            try {
-              const exts = await chrome.developerPrivate.getExtensionsInfo();
-              const bbExt = exts.find(e => e.name === '${EXTENSION_NAME}');
-              
-              if (!bbExt) {
-                return { error: '${EXTENSION_NAME} \u6269\u5C55\u672A\u5B89\u88C5' };
-              }
-              
-              if (bbExt.state !== 'ENABLED') {
-                return { error: '${EXTENSION_NAME} \u6269\u5C55\u5DF2\u7981\u7528' };
-              }
-              
-              await chrome.developerPrivate.reload(bbExt.id, {failQuietly: true});
-              return { success: true, extensionId: bbExt.id };
-            } catch (e) {
-              return { error: e.message };
-            }
-          })()
-        `;
-        ws.send(JSON.stringify({
-          id: 1,
-          method: "Runtime.evaluate",
-          params: {
-            expression: script,
-            awaitPromise: true,
-            returnByValue: true
-          }
-        }));
-      });
-      ws.on("message", (data) => {
-        const msg = JSON.parse(data.toString());
-        if (msg.id === 1) {
-          clearTimeout(timeout);
-          resolved = true;
-          ws.close();
-          const value = msg.result?.result?.value;
-          if (value?.success) {
-            resolve2({
-              success: true,
-              message: "\u6269\u5C55\u5DF2\u91CD\u8F7D",
-              extensionId: value.extensionId
-            });
-          } else if (value?.error) {
-            reject(new Error(value.error));
-          } else {
-            reject(new Error(`\u91CD\u8F7D\u5931\u8D25: ${JSON.stringify(value)}`));
-          }
-        }
-      });
-      ws.on("error", (err) => {
-        clearTimeout(timeout);
-        if (!resolved) {
-          resolved = true;
-          reject(new Error(`CDP \u8FDE\u63A5\u5931\u8D25: ${err.message}`));
-        }
-      });
-    });
-    if (options.json) {
-      console.log(JSON.stringify(result));
-    } else {
-      console.log(`${result.message} (${result.extensionId})`);
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (options.json) {
-      console.log(JSON.stringify({ success: false, error: message }));
-    } else {
-      console.error(`\u9519\u8BEF: ${message}`);
-    }
-    process.exit(1);
-  }
-}
-
 // packages/cli/src/commands/nav.ts
 async function backCommand(options = {}) {
   await ensureDaemonRunning();
@@ -3252,7 +3458,7 @@ async function ensureTabForOrigin(origin, hostname) {
   if (!newResp.success) {
     throw new Error(`\u65E0\u6CD5\u6253\u5F00 ${origin}: ${newResp.error}`);
   }
-  await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+  await new Promise((resolve3) => setTimeout(resolve3, 3e3));
   return newResp.data?.tabId;
 }
 function buildFetchScript(url, options) {
@@ -3398,8 +3604,18 @@ async function historyCommand(subCommand, options = {}) {
   }
 }
 
+// packages/cli/src/commands/daemon.ts
+async function statusCommand(options = {}) {
+  const running = await isDaemonRunning();
+  if (options.json) {
+    console.log(JSON.stringify({ running }));
+  } else {
+    console.log(running ? "\u6D4F\u89C8\u5668\u8FD0\u884C\u4E2D" : "\u6D4F\u89C8\u5668\u672A\u8FD0\u884C");
+  }
+}
+
 // packages/cli/src/index.ts
-var VERSION = "0.8.2";
+var VERSION = "0.9.0";
 var HELP_TEXT = `
 bb-browser - AI Agent \u6D4F\u89C8\u5668\u81EA\u52A8\u5316\u5DE5\u5177
 
@@ -3554,9 +3770,9 @@ async function main() {
     return;
   }
   if (process.argv.includes("--mcp")) {
-    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" });
+    const mcpPath = fileURLToPath4(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;
   }
@@ -3717,24 +3933,6 @@ async function main() {
         break;
       }
       case "daemon":
-      case "start": {
-        const hostIdx = process.argv.findIndex((a) => a === "--host");
-        const host = hostIdx >= 0 ? process.argv[hostIdx + 1] : void 0;
-        await daemonCommand({ json: parsed.flags.json, host });
-        break;
-      }
-      case "stop": {
-        await stopCommand({ json: parsed.flags.json });
-        break;
-      }
-      case "status": {
-        await statusCommand({ json: parsed.flags.json });
-        break;
-      }
-      case "reload": {
-        await reloadCommand({ json: parsed.flags.json });
-        break;
-      }
       case "close": {
         await closeCommand({ json: parsed.flags.json, tabId: globalTabId });
         break;
@@ -3797,6 +3995,10 @@ async function main() {
         await tabCommand(parsed.args, { json: parsed.flags.json });
         break;
       }
+      case "status": {
+        await statusCommand({ json: parsed.flags.json });
+        break;
+      }
       case "frame": {
         const selectorOrMain = parsed.args[0];
         if (!selectorOrMain) {