bb-browser 0.1.0

package/dist/cli.js

@@ -0,0 +1,1800 @@
+#!/usr/bin/env node
+import {
+  COMMAND_TIMEOUT,
+  DAEMON_BASE_URL,
+  generateId
+} from "./chunk-KATHFDYJ.js";
+
+// packages/cli/src/client.ts
+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: "\u6269\u5C55\u672A\u8FDE\u63A5"
+        };
+      }
+      return {
+        id: request.id,
+        success: false,
+        error: `HTTP \u9519\u8BEF: ${res.status} ${res.statusText}`
+      };
+    }
+    return await res.json();
+  } 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("\u65E0\u6CD5\u8FDE\u63A5\u5230 Daemon\uFF0C\u8BF7\u786E\u4FDD Daemon \u6B63\u5728\u8FD0\u884C");
+      }
+      throw error;
+    }
+    throw error;
+  }
+}
+
+// packages/cli/src/daemon-manager.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { fileURLToPath } 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;
+async function isDaemonRunning() {
+  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;
+  }
+}
+async function waitForDaemon(timeoutMs) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    if (await isDaemonRunning()) {
+      return true;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, POLL_INTERVAL));
+  }
+  return false;
+}
+function spawnDaemon() {
+  const daemonPath = getDaemonPath();
+  const daemonProcess = spawn(process.execPath, [daemonPath], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env }
+  });
+  daemonProcess.unref();
+}
+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"
+    );
+  }
+}
+async function stopDaemon() {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(`${DAEMON_BASE_URL}/shutdown`, {
+      method: "POST",
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+// packages/cli/src/commands/open.ts
+async function openCommand(url, options = {}) {
+  if (!url) {
+    throw new Error("\u7F3A\u5C11 URL \u53C2\u6570");
+  }
+  await ensureDaemonRunning();
+  let normalizedUrl = url;
+  if (!url.startsWith("http://") && !url.startsWith("https://")) {
+    normalizedUrl = "https://" + url;
+  }
+  const request = {
+    id: generateId(),
+    action: "open",
+    url: normalizedUrl
+  };
+  if (options.tab !== void 0) {
+    if (options.tab === "current") {
+      request.tabId = "current";
+    } else {
+      const tabId = parseInt(options.tab, 10);
+      if (isNaN(tabId)) {
+        throw new Error(`\u65E0\u6548\u7684 tabId: ${options.tab}`);
+      }
+      request.tabId = tabId;
+    }
+  }
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      console.log(`\u5DF2\u6253\u5F00: ${response.data?.url ?? normalizedUrl}`);
+      if (response.data?.title) {
+        console.log(`\u6807\u9898: ${response.data.title}`);
+      }
+      if (response.data?.tabId) {
+        console.log(`Tab ID: ${response.data.tabId}`);
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/snapshot.ts
+async function snapshotCommand(options = {}) {
+  await ensureDaemonRunning();
+  const request = {
+    id: generateId(),
+    action: "snapshot",
+    interactive: options.interactive
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      console.log(`\u6807\u9898: ${response.data?.title ?? "(\u65E0\u6807\u9898)"}`);
+      console.log(`URL: ${response.data?.url ?? "(\u672A\u77E5)"}`);
+      if (response.data?.snapshotData?.snapshot) {
+        console.log("");
+        console.log(response.data.snapshotData.snapshot);
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/click.ts
+function parseRef(ref) {
+  return ref.startsWith("@") ? ref.slice(1) : ref;
+}
+async function clickCommand(ref, options = {}) {
+  if (!ref) {
+    throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
+  }
+  await ensureDaemonRunning();
+  const parsedRef = parseRef(ref);
+  const request = {
+    id: generateId(),
+    action: "click",
+    ref: parsedRef
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const role = response.data?.role ?? "element";
+      const name = response.data?.name;
+      if (name) {
+        console.log(`\u5DF2\u70B9\u51FB: ${role} "${name}"`);
+      } else {
+        console.log(`\u5DF2\u70B9\u51FB: ${role}`);
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/hover.ts
+function parseRef2(ref) {
+  return ref.startsWith("@") ? ref.slice(1) : ref;
+}
+async function hoverCommand(ref, options = {}) {
+  if (!ref) {
+    throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
+  }
+  await ensureDaemonRunning();
+  const parsedRef = parseRef2(ref);
+  const request = {
+    id: generateId(),
+    action: "hover",
+    ref: parsedRef
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const role = response.data?.role ?? "element";
+      const name = response.data?.name;
+      if (name) {
+        console.log(`\u5DF2\u60AC\u505C: ${role} "${name}"`);
+      } else {
+        console.log(`\u5DF2\u60AC\u505C: ${role}`);
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/fill.ts
+function parseRef3(ref) {
+  return ref.startsWith("@") ? ref.slice(1) : ref;
+}
+async function fillCommand(ref, text, options = {}) {
+  if (!ref) {
+    throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
+  }
+  if (text === void 0 || text === null) {
+    throw new Error("\u7F3A\u5C11 text \u53C2\u6570");
+  }
+  await ensureDaemonRunning();
+  const parsedRef = parseRef3(ref);
+  const request = {
+    id: generateId(),
+    action: "fill",
+    ref: parsedRef,
+    text
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const role = response.data?.role ?? "element";
+      const name = response.data?.name;
+      if (name) {
+        console.log(`\u5DF2\u586B\u5145: ${role} "${name}"`);
+      } else {
+        console.log(`\u5DF2\u586B\u5145: ${role}`);
+      }
+      console.log(`\u5185\u5BB9: "${text}"`);
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/type.ts
+function parseRef4(ref) {
+  return ref.startsWith("@") ? ref.slice(1) : ref;
+}
+async function typeCommand(ref, text, options = {}) {
+  if (!ref) {
+    throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
+  }
+  if (text === void 0 || text === null) {
+    throw new Error("\u7F3A\u5C11 text \u53C2\u6570");
+  }
+  await ensureDaemonRunning();
+  const parsedRef = parseRef4(ref);
+  const request = {
+    id: generateId(),
+    action: "type",
+    ref: parsedRef,
+    text
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const role = response.data?.role ?? "element";
+      const name = response.data?.name;
+      if (name) {
+        console.log(`\u5DF2\u8F93\u5165: ${role} "${name}"`);
+      } else {
+        console.log(`\u5DF2\u8F93\u5165: ${role}`);
+      }
+      console.log(`\u5185\u5BB9: "${text}"`);
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/close.ts
+async function closeCommand(options = {}) {
+  await ensureDaemonRunning();
+  const request = {
+    id: generateId(),
+    action: "close"
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const title = response.data?.title ?? "";
+      if (title) {
+        console.log(`\u5DF2\u5173\u95ED: "${title}"`);
+      } else {
+        console.log("\u5DF2\u5173\u95ED\u5F53\u524D\u6807\u7B7E\u9875");
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/get.ts
+function parseRef5(ref) {
+  return ref.startsWith("@") ? ref.slice(1) : ref;
+}
+async function getCommand(attribute, ref, options = {}) {
+  if (attribute === "text" && !ref) {
+    throw new Error("get text \u9700\u8981 ref \u53C2\u6570\uFF0C\u5982: get text @5");
+  }
+  await ensureDaemonRunning();
+  const request = {
+    id: generateId(),
+    action: "get",
+    attribute,
+    ref: ref ? parseRef5(ref) : void 0
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const value = response.data?.value ?? "";
+      console.log(value);
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/screenshot.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+function getDefaultPath() {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const filename = `bb-screenshot-${timestamp}.png`;
+  return path.join(os.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);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, buffer);
+}
+async function screenshotCommand(outputPath, options = {}) {
+  await ensureDaemonRunning();
+  const filePath = outputPath ? path.resolve(outputPath) : getDefaultPath();
+  const request = {
+    id: generateId(),
+    action: "screenshot"
+  };
+  const response = await sendCommand(request);
+  if (response.success && response.data?.dataUrl) {
+    const dataUrl = response.data.dataUrl;
+    saveBase64Image(dataUrl, filePath);
+    if (options.json) {
+      console.log(JSON.stringify({
+        success: true,
+        path: filePath,
+        base64: dataUrl
+      }, null, 2));
+    } else {
+      console.log(`\u622A\u56FE\u5DF2\u4FDD\u5B58: ${filePath}`);
+    }
+  } else {
+    if (options.json) {
+      console.log(JSON.stringify(response, null, 2));
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+    }
+    process.exit(1);
+  }
+}
+
+// packages/cli/src/commands/wait.ts
+function isTimeWait(target) {
+  return /^\d+$/.test(target);
+}
+function parseRef6(ref) {
+  return ref.startsWith("@") ? ref.slice(1) : ref;
+}
+async function waitCommand(target, options = {}) {
+  if (!target) {
+    throw new Error("\u7F3A\u5C11\u7B49\u5F85\u76EE\u6807\u53C2\u6570");
+  }
+  await ensureDaemonRunning();
+  let request;
+  if (isTimeWait(target)) {
+    const ms = parseInt(target, 10);
+    request = {
+      id: generateId(),
+      action: "wait",
+      waitType: "time",
+      ms
+    };
+  } else {
+    const ref = parseRef6(target);
+    request = {
+      id: generateId(),
+      action: "wait",
+      waitType: "element",
+      ref
+    };
+  }
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      if (isTimeWait(target)) {
+        console.log(`\u5DF2\u7B49\u5F85 ${target}ms`);
+      } else {
+        console.log(`\u5143\u7D20 @${parseRef6(target)} \u5DF2\u51FA\u73B0`);
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/press.ts
+function parseKey(keyString) {
+  const parts = keyString.split("+");
+  const modifierNames = ["Control", "Alt", "Shift", "Meta"];
+  const modifiers = [];
+  let key = "";
+  for (const part of parts) {
+    if (modifierNames.includes(part)) {
+      modifiers.push(part);
+    } else {
+      key = part;
+    }
+  }
+  return { key, modifiers };
+}
+async function pressCommand(keyString, options = {}) {
+  if (!keyString) {
+    throw new Error("\u7F3A\u5C11 key \u53C2\u6570");
+  }
+  await ensureDaemonRunning();
+  const { key, modifiers } = parseKey(keyString);
+  if (!key) {
+    throw new Error("\u65E0\u6548\u7684\u6309\u952E\u683C\u5F0F");
+  }
+  const request = {
+    id: generateId(),
+    action: "press",
+    key,
+    modifiers
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const displayKey = modifiers.length > 0 ? `${modifiers.join("+")}+${key}` : key;
+      console.log(`\u5DF2\u6309\u4E0B: ${displayKey}`);
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/scroll.ts
+var VALID_DIRECTIONS = ["up", "down", "left", "right"];
+var DEFAULT_PIXELS = 300;
+async function scrollCommand(direction, pixels, options = {}) {
+  if (!direction) {
+    throw new Error("\u7F3A\u5C11 direction \u53C2\u6570");
+  }
+  if (!VALID_DIRECTIONS.includes(direction)) {
+    throw new Error(
+      `\u65E0\u6548\u7684\u6EDA\u52A8\u65B9\u5411: ${direction}\uFF0C\u652F\u6301: ${VALID_DIRECTIONS.join(", ")}`
+    );
+  }
+  let pixelValue = DEFAULT_PIXELS;
+  if (pixels !== void 0) {
+    pixelValue = parseInt(pixels, 10);
+    if (isNaN(pixelValue) || pixelValue <= 0) {
+      throw new Error(`\u65E0\u6548\u7684\u50CF\u7D20\u503C: ${pixels}`);
+    }
+  }
+  await ensureDaemonRunning();
+  const request = {
+    id: generateId(),
+    action: "scroll",
+    direction,
+    pixels: pixelValue
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      console.log(`\u5DF2\u6EDA\u52A8: ${direction} ${pixelValue}px`);
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/daemon.ts
+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;
+  }
+  try {
+    const { startDaemon } = await import("@bb-browser/daemon");
+    if (options.json) {
+      console.log(JSON.stringify({ success: true, message: "Daemon \u542F\u52A8\u4E2D..." }));
+    } else {
+      console.log("Daemon \u542F\u52A8\u4E2D...");
+    }
+    await startDaemon();
+  } 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(`\u542F\u52A8\u5931\u8D25: ${message}`);
+    }
+    process.exit(1);
+  }
+}
+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");
+  }
+}
+
+// packages/cli/src/commands/reload.ts
+import WebSocket 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 WebSocket(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();
+  const request = {
+    id: generateId(),
+    action: "back"
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const url = response.data?.url ?? "";
+      if (url) {
+        console.log(`\u540E\u9000\u81F3: ${url}`);
+      } else {
+        console.log("\u5DF2\u540E\u9000");
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+async function forwardCommand(options = {}) {
+  await ensureDaemonRunning();
+  const request = {
+    id: generateId(),
+    action: "forward"
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const url = response.data?.url ?? "";
+      if (url) {
+        console.log(`\u524D\u8FDB\u81F3: ${url}`);
+      } else {
+        console.log("\u5DF2\u524D\u8FDB");
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+async function refreshCommand(options = {}) {
+  await ensureDaemonRunning();
+  const request = {
+    id: generateId(),
+    action: "refresh"
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const title = response.data?.title ?? "";
+      if (title) {
+        console.log(`\u5DF2\u5237\u65B0: "${title}"`);
+      } else {
+        console.log("\u5DF2\u5237\u65B0\u9875\u9762");
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/check.ts
+function parseRef7(ref) {
+  return ref.startsWith("@") ? ref.slice(1) : ref;
+}
+async function checkCommand(ref, options = {}) {
+  if (!ref) {
+    throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
+  }
+  await ensureDaemonRunning();
+  const parsedRef = parseRef7(ref);
+  const request = {
+    id: generateId(),
+    action: "check",
+    ref: parsedRef
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const role = response.data?.role ?? "checkbox";
+      const name = response.data?.name;
+      const wasAlreadyChecked = response.data?.wasAlreadyChecked;
+      if (wasAlreadyChecked) {
+        if (name) {
+          console.log(`\u5DF2\u52FE\u9009\uFF08\u4E4B\u524D\u5DF2\u52FE\u9009\uFF09: ${role} "${name}"`);
+        } else {
+          console.log(`\u5DF2\u52FE\u9009\uFF08\u4E4B\u524D\u5DF2\u52FE\u9009\uFF09: ${role}`);
+        }
+      } else {
+        if (name) {
+          console.log(`\u5DF2\u52FE\u9009: ${role} "${name}"`);
+        } else {
+          console.log(`\u5DF2\u52FE\u9009: ${role}`);
+        }
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+async function uncheckCommand(ref, options = {}) {
+  if (!ref) {
+    throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
+  }
+  await ensureDaemonRunning();
+  const parsedRef = parseRef7(ref);
+  const request = {
+    id: generateId(),
+    action: "uncheck",
+    ref: parsedRef
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const role = response.data?.role ?? "checkbox";
+      const name = response.data?.name;
+      const wasAlreadyUnchecked = response.data?.wasAlreadyUnchecked;
+      if (wasAlreadyUnchecked) {
+        if (name) {
+          console.log(`\u5DF2\u53D6\u6D88\u52FE\u9009\uFF08\u4E4B\u524D\u672A\u52FE\u9009\uFF09: ${role} "${name}"`);
+        } else {
+          console.log(`\u5DF2\u53D6\u6D88\u52FE\u9009\uFF08\u4E4B\u524D\u672A\u52FE\u9009\uFF09: ${role}`);
+        }
+      } else {
+        if (name) {
+          console.log(`\u5DF2\u53D6\u6D88\u52FE\u9009: ${role} "${name}"`);
+        } else {
+          console.log(`\u5DF2\u53D6\u6D88\u52FE\u9009: ${role}`);
+        }
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/select.ts
+function parseRef8(ref) {
+  return ref.startsWith("@") ? ref.slice(1) : ref;
+}
+async function selectCommand(ref, value, options = {}) {
+  if (!ref) {
+    throw new Error("\u7F3A\u5C11 ref \u53C2\u6570");
+  }
+  if (value === void 0 || value === null) {
+    throw new Error("\u7F3A\u5C11 value \u53C2\u6570");
+  }
+  await ensureDaemonRunning();
+  const parsedRef = parseRef8(ref);
+  const request = {
+    id: generateId(),
+    action: "select",
+    ref: parsedRef,
+    value
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const role = response.data?.role ?? "combobox";
+      const name = response.data?.name;
+      const selectedValue = response.data?.selectedValue;
+      const selectedLabel = response.data?.selectedLabel;
+      if (name) {
+        console.log(`\u5DF2\u9009\u62E9: ${role} "${name}"`);
+      } else {
+        console.log(`\u5DF2\u9009\u62E9: ${role}`);
+      }
+      if (selectedLabel && selectedLabel !== selectedValue) {
+        console.log(`\u9009\u9879: "${selectedLabel}" (value="${selectedValue}")`);
+      } else {
+        console.log(`\u9009\u9879: "${selectedValue}"`);
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/eval.ts
+async function evalCommand(script, options = {}) {
+  if (!script) {
+    throw new Error("\u7F3A\u5C11 script \u53C2\u6570");
+  }
+  await ensureDaemonRunning();
+  const request = {
+    id: generateId(),
+    action: "eval",
+    script
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const result = response.data?.result;
+      if (result !== void 0) {
+        if (typeof result === "object" && result !== null) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(result);
+        }
+      } else {
+        console.log("undefined");
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/tab.ts
+function parseTabSubcommand(args) {
+  if (args.length === 0) {
+    return { action: "tab_list" };
+  }
+  const first = args[0];
+  if (first === "new") {
+    return { action: "tab_new", url: args[1] };
+  }
+  if (first === "close") {
+    const indexArg = args[1];
+    if (indexArg !== void 0) {
+      const index2 = parseInt(indexArg, 10);
+      if (isNaN(index2) || index2 < 0) {
+        throw new Error(`\u65E0\u6548\u7684\u6807\u7B7E\u9875\u7D22\u5F15: ${indexArg}`);
+      }
+      return { action: "tab_close", index: index2 };
+    }
+    return { action: "tab_close" };
+  }
+  const index = parseInt(first, 10);
+  if (!isNaN(index) && index >= 0) {
+    return { action: "tab_select", index };
+  }
+  throw new Error(`\u672A\u77E5\u7684 tab \u5B50\u547D\u4EE4: ${first}`);
+}
+function formatTabList(tabs, activeIndex) {
+  const lines = [];
+  lines.push(`\u6807\u7B7E\u9875\u5217\u8868\uFF08\u5171 ${tabs.length} \u4E2A\uFF0C\u5F53\u524D #${activeIndex}\uFF09\uFF1A`);
+  for (const tab of tabs) {
+    const prefix = tab.active ? "*" : " ";
+    const title = tab.title || "(\u65E0\u6807\u9898)";
+    lines.push(`${prefix} [${tab.index}] ${tab.url} - ${title}`);
+  }
+  return lines.join("\n");
+}
+async function tabCommand(args, options = {}) {
+  await ensureDaemonRunning();
+  const parsed = parseTabSubcommand(args);
+  const request = {
+    id: generateId(),
+    action: parsed.action,
+    url: parsed.url,
+    index: parsed.index
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      switch (parsed.action) {
+        case "tab_list": {
+          const tabs = response.data?.tabs ?? [];
+          const activeIndex = response.data?.activeIndex ?? 0;
+          console.log(formatTabList(tabs, activeIndex));
+          break;
+        }
+        case "tab_new": {
+          const url = response.data?.url ?? "about:blank";
+          console.log(`\u5DF2\u521B\u5EFA\u65B0\u6807\u7B7E\u9875: ${url}`);
+          break;
+        }
+        case "tab_select": {
+          const title = response.data?.title ?? "(\u65E0\u6807\u9898)";
+          const url = response.data?.url ?? "";
+          console.log(`\u5DF2\u5207\u6362\u5230\u6807\u7B7E\u9875 #${parsed.index}: ${title}`);
+          console.log(`  URL: ${url}`);
+          break;
+        }
+        case "tab_close": {
+          const closedTitle = response.data?.title ?? "(\u65E0\u6807\u9898)";
+          console.log(`\u5DF2\u5173\u95ED\u6807\u7B7E\u9875: ${closedTitle}`);
+          break;
+        }
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/frame.ts
+async function frameCommand(selector, options = {}) {
+  if (!selector) {
+    throw new Error("\u7F3A\u5C11 selector \u53C2\u6570");
+  }
+  await ensureDaemonRunning();
+  const request = {
+    id: generateId(),
+    action: "frame",
+    selector
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const frameInfo = response.data?.frameInfo;
+      if (frameInfo?.url) {
+        console.log(`\u5DF2\u5207\u6362\u5230 frame: ${selector} (${frameInfo.url})`);
+      } else {
+        console.log(`\u5DF2\u5207\u6362\u5230 frame: ${selector}`);
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+async function frameMainCommand(options = {}) {
+  await ensureDaemonRunning();
+  const request = {
+    id: generateId(),
+    action: "frame_main"
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      console.log("\u5DF2\u8FD4\u56DE\u4E3B frame");
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/dialog.ts
+async function dialogCommand(subCommand, promptText, options = {}) {
+  if (!subCommand || !["accept", "dismiss"].includes(subCommand)) {
+    throw new Error("\u8BF7\u4F7F\u7528 'dialog accept [text]' \u6216 'dialog dismiss'");
+  }
+  await ensureDaemonRunning();
+  const request = {
+    id: generateId(),
+    action: "dialog",
+    dialogResponse: subCommand,
+    promptText: subCommand === "accept" ? promptText : void 0
+  };
+  const response = await sendCommand(request);
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+  } else {
+    if (response.success) {
+      const dialogInfo = response.data?.dialogInfo;
+      if (dialogInfo) {
+        const action = subCommand === "accept" ? "\u5DF2\u63A5\u53D7" : "\u5DF2\u62D2\u7EDD";
+        console.log(`${action}\u5BF9\u8BDD\u6846\uFF08${dialogInfo.type}\uFF09: "${dialogInfo.message}"`);
+      } else {
+        console.log("\u5BF9\u8BDD\u6846\u5DF2\u5904\u7406");
+      }
+    } else {
+      console.error(`\u9519\u8BEF: ${response.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+// packages/cli/src/commands/network.ts
+async function networkCommand(subCommand, urlOrFilter, options = {}) {
+  const response = await sendCommand({
+    id: crypto.randomUUID(),
+    action: "network",
+    networkCommand: subCommand,
+    url: subCommand === "route" || subCommand === "unroute" ? urlOrFilter : void 0,
+    filter: subCommand === "requests" ? urlOrFilter : void 0,
+    routeOptions: subCommand === "route" ? {
+      abort: options.abort,
+      body: options.body
+    } : void 0
+  });
+  if (options.json) {
+    console.log(JSON.stringify(response));
+    return;
+  }
+  if (!response.success) {
+    throw new Error(response.error || "Network command failed");
+  }
+  const data = response.data;
+  switch (subCommand) {
+    case "requests": {
+      const requests = data?.networkRequests || [];
+      if (requests.length === 0) {
+        console.log("\u6CA1\u6709\u7F51\u7EDC\u8BF7\u6C42\u8BB0\u5F55");
+        console.log("\u63D0\u793A: \u4F7F\u7528 network requests \u4F1A\u81EA\u52A8\u5F00\u59CB\u76D1\u63A7");
+      } else {
+        console.log(`\u7F51\u7EDC\u8BF7\u6C42 (${requests.length} \u6761):
+`);
+        for (const req of requests) {
+          const status = req.failed ? `FAILED (${req.failureReason})` : req.status ? `${req.status} ${req.statusText || ""}` : "pending";
+          console.log(`${req.method} ${req.url}`);
+          console.log(`  \u7C7B\u578B: ${req.type}, \u72B6\u6001: ${status}`);
+          console.log("");
+        }
+      }
+      break;
+    }
+    case "route": {
+      console.log(`\u5DF2\u6DFB\u52A0\u62E6\u622A\u89C4\u5219: ${urlOrFilter}`);
+      if (options.abort) {
+        console.log("  \u884C\u4E3A: \u963B\u6B62\u8BF7\u6C42");
+      } else if (options.body) {
+        console.log("  \u884C\u4E3A: \u8FD4\u56DE mock \u6570\u636E");
+      } else {
+        console.log("  \u884C\u4E3A: \u7EE7\u7EED\u8BF7\u6C42");
+      }
+      console.log(`\u5F53\u524D\u89C4\u5219\u6570: ${data?.routeCount || 0}`);
+      break;
+    }
+    case "unroute": {
+      if (urlOrFilter) {
+        console.log(`\u5DF2\u79FB\u9664\u62E6\u622A\u89C4\u5219: ${urlOrFilter}`);
+      } else {
+        console.log("\u5DF2\u79FB\u9664\u6240\u6709\u62E6\u622A\u89C4\u5219");
+      }
+      console.log(`\u5269\u4F59\u89C4\u5219\u6570: ${data?.routeCount || 0}`);
+      break;
+    }
+    case "clear": {
+      console.log("\u5DF2\u6E05\u7A7A\u7F51\u7EDC\u8BF7\u6C42\u8BB0\u5F55");
+      break;
+    }
+    default:
+      throw new Error(`\u672A\u77E5\u7684 network \u5B50\u547D\u4EE4: ${subCommand}`);
+  }
+}
+
+// packages/cli/src/commands/console.ts
+async function consoleCommand(options = {}) {
+  const response = await sendCommand({
+    id: crypto.randomUUID(),
+    action: "console",
+    consoleCommand: options.clear ? "clear" : "get"
+  });
+  if (options.json) {
+    console.log(JSON.stringify(response));
+    return;
+  }
+  if (!response.success) {
+    throw new Error(response.error || "Console command failed");
+  }
+  if (options.clear) {
+    console.log("\u5DF2\u6E05\u7A7A\u63A7\u5236\u53F0\u6D88\u606F");
+    return;
+  }
+  const messages = response.data?.consoleMessages || [];
+  if (messages.length === 0) {
+    console.log("\u6CA1\u6709\u63A7\u5236\u53F0\u6D88\u606F");
+    console.log("\u63D0\u793A: console \u547D\u4EE4\u4F1A\u81EA\u52A8\u5F00\u59CB\u76D1\u63A7");
+    return;
+  }
+  console.log(`\u63A7\u5236\u53F0\u6D88\u606F (${messages.length} \u6761):
+`);
+  const typeColors = {
+    log: "",
+    info: "[INFO]",
+    warn: "[WARN]",
+    error: "[ERROR]",
+    debug: "[DEBUG]"
+  };
+  for (const msg of messages) {
+    const prefix = typeColors[msg.type] || `[${msg.type.toUpperCase()}]`;
+    const location = msg.url ? ` (${msg.url}${msg.lineNumber ? `:${msg.lineNumber}` : ""})` : "";
+    if (prefix) {
+      console.log(`${prefix} ${msg.text}${location}`);
+    } else {
+      console.log(`${msg.text}${location}`);
+    }
+  }
+}
+
+// packages/cli/src/commands/errors.ts
+async function errorsCommand(options = {}) {
+  const response = await sendCommand({
+    id: crypto.randomUUID(),
+    action: "errors",
+    errorsCommand: options.clear ? "clear" : "get"
+  });
+  if (options.json) {
+    console.log(JSON.stringify(response));
+    return;
+  }
+  if (!response.success) {
+    throw new Error(response.error || "Errors command failed");
+  }
+  if (options.clear) {
+    console.log("\u5DF2\u6E05\u7A7A JS \u9519\u8BEF\u8BB0\u5F55");
+    return;
+  }
+  const errors = response.data?.jsErrors || [];
+  if (errors.length === 0) {
+    console.log("\u6CA1\u6709 JS \u9519\u8BEF");
+    console.log("\u63D0\u793A: errors \u547D\u4EE4\u4F1A\u81EA\u52A8\u5F00\u59CB\u76D1\u63A7");
+    return;
+  }
+  console.log(`JS \u9519\u8BEF (${errors.length} \u6761):
+`);
+  for (const err of errors) {
+    console.log(`[ERROR] ${err.message}`);
+    if (err.url) {
+      console.log(`  \u4F4D\u7F6E: ${err.url}:${err.lineNumber || 0}:${err.columnNumber || 0}`);
+    }
+    if (err.stackTrace) {
+      console.log(`  \u5806\u6808:`);
+      console.log(err.stackTrace.split("\n").map((line) => `    ${line}`).join("\n"));
+    }
+    console.log("");
+  }
+}
+
+// packages/cli/src/commands/trace.ts
+async function traceCommand(subCommand, options = {}) {
+  const response = await sendCommand({
+    id: crypto.randomUUID(),
+    action: "trace",
+    traceCommand: subCommand
+  });
+  if (options.json) {
+    console.log(JSON.stringify(response));
+    return;
+  }
+  if (!response.success) {
+    throw new Error(response.error || "Trace command failed");
+  }
+  const data = response.data;
+  switch (subCommand) {
+    case "start": {
+      const status = data?.traceStatus;
+      console.log("\u5F00\u59CB\u5F55\u5236\u7528\u6237\u64CD\u4F5C");
+      console.log(`\u6807\u7B7E\u9875 ID: ${status?.tabId || "N/A"}`);
+      console.log("\n\u5728\u6D4F\u89C8\u5668\u4E2D\u8FDB\u884C\u64CD\u4F5C\uFF0C\u5B8C\u6210\u540E\u8FD0\u884C 'bb-browser trace stop' \u505C\u6B62\u5F55\u5236");
+      break;
+    }
+    case "stop": {
+      const events = data?.traceEvents || [];
+      const status = data?.traceStatus;
+      console.log(`\u5F55\u5236\u5B8C\u6210\uFF0C\u5171 ${events.length} \u4E2A\u4E8B\u4EF6
+`);
+      if (events.length === 0) {
+        console.log("\u6CA1\u6709\u5F55\u5236\u5230\u4EFB\u4F55\u64CD\u4F5C");
+        break;
+      }
+      for (let i = 0; i < events.length; i++) {
+        const event = events[i];
+        const refStr = event.ref !== void 0 ? `@${event.ref}` : "";
+        switch (event.type) {
+          case "navigation":
+            console.log(`${i + 1}. \u5BFC\u822A\u5230: ${event.url}`);
+            break;
+          case "click":
+            console.log(`${i + 1}. \u70B9\u51FB ${refStr} [${event.elementRole}] "${event.elementName || ""}"`);
+            break;
+          case "fill":
+            console.log(`${i + 1}. \u586B\u5145 ${refStr} [${event.elementRole}] "${event.elementName || ""}" <- "${event.value}"`);
+            break;
+          case "select":
+            console.log(`${i + 1}. \u9009\u62E9 ${refStr} [${event.elementRole}] "${event.elementName || ""}" <- "${event.value}"`);
+            break;
+          case "check":
+            console.log(`${i + 1}. ${event.checked ? "\u52FE\u9009" : "\u53D6\u6D88\u52FE\u9009"} ${refStr} [${event.elementRole}] "${event.elementName || ""}"`);
+            break;
+          case "press":
+            console.log(`${i + 1}. \u6309\u952E ${event.key}`);
+            break;
+          case "scroll":
+            console.log(`${i + 1}. \u6EDA\u52A8 ${event.direction} ${event.pixels}px`);
+            break;
+          default:
+            console.log(`${i + 1}. ${event.type}`);
+        }
+      }
+      console.log(`
+\u72B6\u6001: ${status?.recording ? "\u5F55\u5236\u4E2D" : "\u5DF2\u505C\u6B62"}`);
+      break;
+    }
+    case "status": {
+      const status = data?.traceStatus;
+      if (status?.recording) {
+        console.log(`\u5F55\u5236\u4E2D (\u6807\u7B7E\u9875 ${status.tabId})`);
+        console.log(`\u5DF2\u5F55\u5236 ${status.eventCount} \u4E2A\u4E8B\u4EF6`);
+      } else {
+        console.log("\u672A\u5728\u5F55\u5236");
+      }
+      break;
+    }
+    default:
+      throw new Error(`\u672A\u77E5\u7684 trace \u5B50\u547D\u4EE4: ${subCommand}`);
+  }
+}
+
+// packages/cli/src/index.ts
+var VERSION = "0.1.0";
+var HELP_TEXT = `
+bb-browser - AI Agent \u6D4F\u89C8\u5668\u81EA\u52A8\u5316\u5DE5\u5177
+
+\u7528\u6CD5\uFF1A
+  bb-browser <command> [options]
+
+\u547D\u4EE4\uFF1A
+  open <url> [--tab] \u6253\u5F00\u6307\u5B9A URL\uFF08\u9ED8\u8BA4\u65B0 tab\uFF0C--tab current \u5F53\u524D tab\uFF09
+  snapshot          \u83B7\u53D6\u5F53\u524D\u9875\u9762\u5FEB\u7167\uFF08\u9ED8\u8BA4\u5B8C\u6574\u6811\uFF09
+  click <ref>       \u70B9\u51FB\u5143\u7D20\uFF08ref \u5982 @5 \u6216 5\uFF09
+  hover <ref>       \u60AC\u505C\u5728\u5143\u7D20\u4E0A
+  fill <ref> <text> \u586B\u5145\u8F93\u5165\u6846\uFF08\u6E05\u7A7A\u540E\u586B\u5165\uFF09
+  type <ref> <text> \u9010\u5B57\u7B26\u8F93\u5165\uFF08\u4E0D\u6E05\u7A7A\uFF09
+  check <ref>       \u52FE\u9009\u590D\u9009\u6846
+  uncheck <ref>     \u53D6\u6D88\u52FE\u9009\u590D\u9009\u6846
+  select <ref> <val> \u4E0B\u62C9\u6846\u9009\u62E9
+  eval "<js>"       \u6267\u884C JavaScript
+  close             \u5173\u95ED\u5F53\u524D\u6807\u7B7E\u9875
+  get text <ref>    \u83B7\u53D6\u5143\u7D20\u6587\u672C
+  get url           \u83B7\u53D6\u5F53\u524D\u9875\u9762 URL
+  get title         \u83B7\u53D6\u9875\u9762\u6807\u9898
+  screenshot [path] \u622A\u53D6\u5F53\u524D\u9875\u9762
+  wait <ms|@ref>    \u7B49\u5F85\u65F6\u95F4\u6216\u5143\u7D20
+  press <key>       \u53D1\u9001\u952E\u76D8\u6309\u952E\uFF08\u5982 Enter, Tab, Control+a\uFF09
+  scroll <dir> [px] \u6EDA\u52A8\u9875\u9762\uFF08up/down/left/right\uFF0C\u9ED8\u8BA4 300px\uFF09
+  daemon            \u524D\u53F0\u542F\u52A8 Daemon
+  start             \u524D\u53F0\u542F\u52A8 Daemon\uFF08daemon \u7684\u522B\u540D\uFF09
+  stop              \u505C\u6B62 Daemon
+  status            \u67E5\u770B Daemon \u72B6\u6001
+  reload            \u91CD\u8F7D\u6269\u5C55\uFF08\u9700\u8981 CDP \u6A21\u5F0F\uFF09
+  back              \u540E\u9000
+  forward           \u524D\u8FDB
+  refresh           \u5237\u65B0\u9875\u9762
+  tab               \u5217\u51FA\u6240\u6709\u6807\u7B7E\u9875
+  tab new [url]     \u65B0\u5EFA\u6807\u7B7E\u9875
+  tab <n>           \u5207\u6362\u5230\u7B2C n \u4E2A\u6807\u7B7E\u9875
+  tab close [n]     \u5173\u95ED\u6807\u7B7E\u9875\uFF08\u9ED8\u8BA4\u5F53\u524D\uFF09
+  frame <selector>  \u5207\u6362\u5230\u6307\u5B9A iframe
+  frame main        \u8FD4\u56DE\u4E3B frame
+  dialog accept [text]  \u63A5\u53D7\u5BF9\u8BDD\u6846\uFF08alert/confirm/prompt\uFF09
+  dialog dismiss    \u62D2\u7EDD/\u5173\u95ED\u5BF9\u8BDD\u6846
+  network requests [filter]  \u67E5\u770B\u7F51\u7EDC\u8BF7\u6C42
+  network route <url> [--abort|--body <json>]  \u62E6\u622A\u8BF7\u6C42
+  network unroute [url]  \u79FB\u9664\u62E6\u622A\u89C4\u5219
+  network clear     \u6E05\u7A7A\u8BF7\u6C42\u8BB0\u5F55
+  console           \u67E5\u770B\u63A7\u5236\u53F0\u6D88\u606F
+  console --clear   \u6E05\u7A7A\u63A7\u5236\u53F0
+  errors            \u67E5\u770B JS \u9519\u8BEF
+  errors --clear    \u6E05\u7A7A\u9519\u8BEF\u8BB0\u5F55
+  trace start       \u5F00\u59CB\u5F55\u5236\u7528\u6237\u64CD\u4F5C
+  trace stop        \u505C\u6B62\u5F55\u5236\uFF0C\u8F93\u51FA\u4E8B\u4EF6\u5217\u8868
+  trace status      \u67E5\u770B\u5F55\u5236\u72B6\u6001
+
+\u9009\u9879\uFF1A
+  --json          \u4EE5 JSON \u683C\u5F0F\u8F93\u51FA
+  -i, --interactive \u53EA\u8F93\u51FA\u53EF\u4EA4\u4E92\u5143\u7D20\uFF08snapshot \u547D\u4EE4\uFF09
+  --help, -h      \u663E\u793A\u5E2E\u52A9\u4FE1\u606F
+  --version, -v   \u663E\u793A\u7248\u672C\u53F7
+
+\u793A\u4F8B\uFF1A
+  bb-browser open https://example.com
+  bb-browser snapshot --json
+  bb-browser click @5
+  bb-browser fill @3 "hello world"
+  bb-browser type @3 "append text"
+  bb-browser get text @5
+  bb-browser get url
+  bb-browser press Enter
+  bb-browser press Control+a
+  bb-browser daemon
+  bb-browser stop
+`.trim();
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const result = {
+    command: null,
+    args: [],
+    flags: {
+      json: false,
+      help: false,
+      version: false,
+      interactive: false
+    }
+  };
+  for (const arg of args) {
+    if (arg === "--json") {
+      result.flags.json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      result.flags.help = true;
+    } else if (arg === "--version" || arg === "-v") {
+      result.flags.version = true;
+    } else if (arg === "--interactive" || arg === "-i") {
+      result.flags.interactive = true;
+    } else if (arg.startsWith("-")) {
+    } else if (result.command === null) {
+      result.command = arg;
+    } else {
+      result.args.push(arg);
+    }
+  }
+  return result;
+}
+async function main() {
+  const parsed = parseArgs(process.argv);
+  if (parsed.flags.version) {
+    console.log(VERSION);
+    return;
+  }
+  if (parsed.flags.help || !parsed.command) {
+    console.log(HELP_TEXT);
+    return;
+  }
+  try {
+    switch (parsed.command) {
+      case "open": {
+        const url = parsed.args[0];
+        if (!url) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11 URL \u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser open <url> [--tab current|<tabId>]");
+          process.exit(1);
+        }
+        const tabIndex = process.argv.findIndex((a) => a === "--tab");
+        const tab = tabIndex >= 0 ? process.argv[tabIndex + 1] : void 0;
+        await openCommand(url, { json: parsed.flags.json, tab });
+        break;
+      }
+      case "snapshot": {
+        await snapshotCommand({ json: parsed.flags.json, interactive: parsed.flags.interactive });
+        break;
+      }
+      case "click": {
+        const ref = parsed.args[0];
+        if (!ref) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11 ref \u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser click <ref>");
+          console.error("\u793A\u4F8B\uFF1Abb-browser click @5");
+          process.exit(1);
+        }
+        await clickCommand(ref, { json: parsed.flags.json });
+        break;
+      }
+      case "hover": {
+        const ref = parsed.args[0];
+        if (!ref) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11 ref \u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser hover <ref>");
+          console.error("\u793A\u4F8B\uFF1Abb-browser hover @5");
+          process.exit(1);
+        }
+        await hoverCommand(ref, { json: parsed.flags.json });
+        break;
+      }
+      case "check": {
+        const ref = parsed.args[0];
+        if (!ref) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11 ref \u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser check <ref>");
+          console.error("\u793A\u4F8B\uFF1Abb-browser check @5");
+          process.exit(1);
+        }
+        await checkCommand(ref, { json: parsed.flags.json });
+        break;
+      }
+      case "uncheck": {
+        const ref = parsed.args[0];
+        if (!ref) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11 ref \u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser uncheck <ref>");
+          console.error("\u793A\u4F8B\uFF1Abb-browser uncheck @5");
+          process.exit(1);
+        }
+        await uncheckCommand(ref, { json: parsed.flags.json });
+        break;
+      }
+      case "fill": {
+        const ref = parsed.args[0];
+        const text = parsed.args[1];
+        if (!ref) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11 ref \u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser fill <ref> <text>");
+          console.error('\u793A\u4F8B\uFF1Abb-browser fill @3 "hello world"');
+          process.exit(1);
+        }
+        if (text === void 0) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11 text \u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser fill <ref> <text>");
+          console.error('\u793A\u4F8B\uFF1Abb-browser fill @3 "hello world"');
+          process.exit(1);
+        }
+        await fillCommand(ref, text, { json: parsed.flags.json });
+        break;
+      }
+      case "type": {
+        const ref = parsed.args[0];
+        const text = parsed.args[1];
+        if (!ref) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11 ref \u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser type <ref> <text>");
+          console.error('\u793A\u4F8B\uFF1Abb-browser type @3 "append text"');
+          process.exit(1);
+        }
+        if (text === void 0) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11 text \u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser type <ref> <text>");
+          console.error('\u793A\u4F8B\uFF1Abb-browser type @3 "append text"');
+          process.exit(1);
+        }
+        await typeCommand(ref, text, { json: parsed.flags.json });
+        break;
+      }
+      case "select": {
+        const ref = parsed.args[0];
+        const value = parsed.args[1];
+        if (!ref) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11 ref \u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser select <ref> <value>");
+          console.error('\u793A\u4F8B\uFF1Abb-browser select @4 "option1"');
+          process.exit(1);
+        }
+        if (value === void 0) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11 value \u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser select <ref> <value>");
+          console.error('\u793A\u4F8B\uFF1Abb-browser select @4 "option1"');
+          process.exit(1);
+        }
+        await selectCommand(ref, value, { json: parsed.flags.json });
+        break;
+      }
+      case "eval": {
+        const script = parsed.args[0];
+        if (!script) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11 script \u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser eval <script>");
+          console.error('\u793A\u4F8B\uFF1Abb-browser eval "document.title"');
+          process.exit(1);
+        }
+        await evalCommand(script, { json: parsed.flags.json });
+        break;
+      }
+      case "get": {
+        const attribute = parsed.args[0];
+        if (!attribute) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11\u5C5E\u6027\u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser get <text|url|title> [ref]");
+          console.error("\u793A\u4F8B\uFF1Abb-browser get text @5");
+          console.error("      bb-browser get url");
+          process.exit(1);
+        }
+        if (!["text", "url", "title"].includes(attribute)) {
+          console.error(`\u9519\u8BEF\uFF1A\u672A\u77E5\u5C5E\u6027 "${attribute}"`);
+          console.error("\u652F\u6301\u7684\u5C5E\u6027\uFF1Atext, url, title");
+          process.exit(1);
+        }
+        const ref = parsed.args[1];
+        await getCommand(attribute, ref, { json: parsed.flags.json });
+        break;
+      }
+      case "daemon":
+      case "start": {
+        await daemonCommand({ json: parsed.flags.json });
+        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 });
+        break;
+      }
+      case "back": {
+        await backCommand({ json: parsed.flags.json });
+        break;
+      }
+      case "forward": {
+        await forwardCommand({ json: parsed.flags.json });
+        break;
+      }
+      case "refresh": {
+        await refreshCommand({ json: parsed.flags.json });
+        break;
+      }
+      case "screenshot": {
+        const outputPath = parsed.args[0];
+        await screenshotCommand(outputPath, { json: parsed.flags.json });
+        break;
+      }
+      case "wait": {
+        const target = parsed.args[0];
+        if (!target) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11\u7B49\u5F85\u76EE\u6807\u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser wait <ms|@ref>");
+          console.error("\u793A\u4F8B\uFF1Abb-browser wait 2000");
+          console.error("      bb-browser wait @5");
+          process.exit(1);
+        }
+        await waitCommand(target, { json: parsed.flags.json });
+        break;
+      }
+      case "press": {
+        const key = parsed.args[0];
+        if (!key) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11 key \u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser press <key>");
+          console.error("\u793A\u4F8B\uFF1Abb-browser press Enter");
+          console.error("      bb-browser press Control+a");
+          process.exit(1);
+        }
+        await pressCommand(key, { json: parsed.flags.json });
+        break;
+      }
+      case "scroll": {
+        const direction = parsed.args[0];
+        const pixels = parsed.args[1];
+        if (!direction) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11\u65B9\u5411\u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser scroll <up|down|left|right> [pixels]");
+          console.error("\u793A\u4F8B\uFF1Abb-browser scroll down");
+          console.error("      bb-browser scroll up 500");
+          process.exit(1);
+        }
+        await scrollCommand(direction, pixels, { json: parsed.flags.json });
+        break;
+      }
+      case "tab": {
+        await tabCommand(parsed.args, { json: parsed.flags.json });
+        break;
+      }
+      case "frame": {
+        const selectorOrMain = parsed.args[0];
+        if (!selectorOrMain) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11 selector \u53C2\u6570");
+          console.error("\u7528\u6CD5\uFF1Abb-browser frame <selector>");
+          console.error('\u793A\u4F8B\uFF1Abb-browser frame "iframe#editor"');
+          console.error("      bb-browser frame main");
+          process.exit(1);
+        }
+        if (selectorOrMain === "main") {
+          await frameMainCommand({ json: parsed.flags.json });
+        } else {
+          await frameCommand(selectorOrMain, { json: parsed.flags.json });
+        }
+        break;
+      }
+      case "dialog": {
+        const subCommand = parsed.args[0];
+        if (!subCommand) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11\u5B50\u547D\u4EE4");
+          console.error("\u7528\u6CD5\uFF1Abb-browser dialog <accept|dismiss> [text]");
+          console.error("\u793A\u4F8B\uFF1Abb-browser dialog accept");
+          console.error('      bb-browser dialog accept "my input"');
+          console.error("      bb-browser dialog dismiss");
+          process.exit(1);
+        }
+        const promptText = parsed.args[1];
+        await dialogCommand(subCommand, promptText, { json: parsed.flags.json });
+        break;
+      }
+      case "network": {
+        const subCommand = parsed.args[0] || "requests";
+        const urlOrFilter = parsed.args[1];
+        const abort = process.argv.includes("--abort");
+        const bodyIndex = process.argv.findIndex((a) => a === "--body");
+        const body = bodyIndex >= 0 ? process.argv[bodyIndex + 1] : void 0;
+        await networkCommand(subCommand, urlOrFilter, { json: parsed.flags.json, abort, body });
+        break;
+      }
+      case "console": {
+        const clear = process.argv.includes("--clear");
+        await consoleCommand({ json: parsed.flags.json, clear });
+        break;
+      }
+      case "errors": {
+        const clear = process.argv.includes("--clear");
+        await errorsCommand({ json: parsed.flags.json, clear });
+        break;
+      }
+      case "trace": {
+        const subCmd = parsed.args[0];
+        if (!subCmd || !["start", "stop", "status"].includes(subCmd)) {
+          console.error("\u9519\u8BEF\uFF1A\u7F3A\u5C11\u6216\u65E0\u6548\u7684\u5B50\u547D\u4EE4");
+          console.error("\u7528\u6CD5\uFF1Abb-browser trace <start|stop|status>");
+          console.error("\u793A\u4F8B\uFF1Abb-browser trace start");
+          console.error("      bb-browser trace stop");
+          console.error("      bb-browser trace status");
+          process.exit(1);
+        }
+        await traceCommand(subCmd, { json: parsed.flags.json });
+        break;
+      }
+      default: {
+        console.error(`\u9519\u8BEF\uFF1A\u672A\u77E5\u547D\u4EE4 "${parsed.command}"`);
+        console.error("\u8FD0\u884C bb-browser --help \u67E5\u770B\u53EF\u7528\u547D\u4EE4");
+        process.exit(1);
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (parsed.flags.json) {
+      console.log(
+        JSON.stringify({
+          success: false,
+          error: message
+        })
+      );
+    } else {
+      console.error(`\u9519\u8BEF\uFF1A${message}`);
+    }
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=cli.js.map