bb-browser 0.3.0 → 0.4.1

package/dist/cli.js

@@ -3,7 +3,7 @@ import {
   COMMAND_TIMEOUT,
   DAEMON_BASE_URL,
   generateId
-} from "./chunk-TUO443YI.js";
+} from "./chunk-H7M4J4CW.js";
 
 // packages/cli/src/client.ts
 async function sendCommand(request) {
@@ -600,6 +600,7 @@ async function scrollCommand(direction, pixels, options = {}) {
 }
 
 // packages/cli/src/commands/daemon.ts
+import { spawn as spawn2 } from "child_process";
 async function daemonCommand(options = {}) {
   if (await isDaemonRunning()) {
     if (options.json) {
@@ -609,23 +610,29 @@ async function daemonCommand(options = {}) {
     }
     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);
+  const daemonPath = getDaemonPath();
+  const args = [daemonPath];
+  if (options.host) {
+    args.push("--host", options.host);
   }
+  if (options.json) {
+    console.log(JSON.stringify({ success: true, message: "Daemon \u542F\u52A8\u4E2D..." }));
+  } else {
+    console.log("Daemon \u542F\u52A8\u4E2D...");
+  }
+  await new Promise((resolve2, reject) => {
+    const child = spawn2(process.execPath, args, {
+      stdio: "inherit"
+    });
+    child.on("exit", (code) => {
+      if (code && code !== 0) {
+        reject(new Error(`Daemon exited with code ${code}`));
+      } else {
+        resolve2();
+      }
+    });
+    child.on("error", reject);
+  });
 }
 async function stopCommand(options = {}) {
   if (!await isDaemonRunning()) {
@@ -1200,6 +1207,7 @@ async function networkCommand(subCommand, urlOrFilter, options = {}) {
       abort: options.abort,
       body: options.body
     } : void 0,
+    withBody: subCommand === "requests" ? options.withBody : void 0,
     tabId: options.tabId
   });
   if (options.json) {
@@ -1223,6 +1231,22 @@ async function networkCommand(subCommand, urlOrFilter, options = {}) {
           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}`);
+          if (options.withBody) {
+            const requestHeaderCount = req.requestHeaders ? Object.keys(req.requestHeaders).length : 0;
+            const responseHeaderCount = req.responseHeaders ? Object.keys(req.responseHeaders).length : 0;
+            console.log(`  \u8BF7\u6C42\u5934: ${requestHeaderCount}, \u54CD\u5E94\u5934: ${responseHeaderCount}`);
+            if (req.requestBody !== void 0) {
+              const preview = req.requestBody.length > 200 ? `${req.requestBody.slice(0, 200)}...` : req.requestBody;
+              console.log(`  \u8BF7\u6C42\u4F53: ${preview}`);
+            }
+            if (req.responseBody !== void 0) {
+              const preview = req.responseBody.length > 200 ? `${req.responseBody.slice(0, 200)}...` : req.responseBody;
+              console.log(`  \u54CD\u5E94\u4F53: ${preview}`);
+            }
+            if (req.bodyError) {
+              console.log(`  Body\u9519\u8BEF: ${req.bodyError}`);
+            }
+          }
           console.log("");
         }
       }
@@ -1424,6 +1448,500 @@ async function traceCommand(subCommand, options = {}) {
   }
 }
 
+// packages/cli/src/commands/fetch.ts
+function matchTabOrigin(tabUrl, targetHostname) {
+  try {
+    const tabHostname = new URL(tabUrl).hostname;
+    return tabHostname === targetHostname || tabHostname.endsWith("." + targetHostname);
+  } catch {
+    return false;
+  }
+}
+async function ensureTabForOrigin(origin, hostname) {
+  const listReq = { id: generateId(), action: "tab_list" };
+  const listResp = await sendCommand(listReq);
+  if (listResp.success && listResp.data?.tabs) {
+    const matchingTab = listResp.data.tabs.find(
+      (tab) => matchTabOrigin(tab.url, hostname)
+    );
+    if (matchingTab) {
+      return matchingTab.tabId;
+    }
+  }
+  const newResp = await sendCommand({ id: generateId(), action: "tab_new", url: origin });
+  if (!newResp.success) {
+    throw new Error(`\u65E0\u6CD5\u6253\u5F00 ${origin}: ${newResp.error}`);
+  }
+  await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+  return newResp.data?.tabId;
+}
+function buildFetchScript(url, options) {
+  const method = (options.method || "GET").toUpperCase();
+  const hasBody = options.body && method !== "GET" && method !== "HEAD";
+  let headersExpr = "{}";
+  if (options.headers) {
+    try {
+      JSON.parse(options.headers);
+      headersExpr = options.headers;
+    } catch {
+      throw new Error(`--headers must be valid JSON. Got: ${options.headers}`);
+    }
+  }
+  return `(async () => {
+    try {
+      const resp = await fetch(${JSON.stringify(url)}, {
+        method: ${JSON.stringify(method)},
+        credentials: 'include',
+        headers: ${headersExpr}${hasBody ? `,
+        body: ${JSON.stringify(options.body)}` : ""}
+      });
+      const contentType = resp.headers.get('content-type') || '';
+      let body;
+      if (contentType.includes('application/json') && resp.status !== 204) {
+        try { body = await resp.json(); } catch { body = await resp.text(); }
+      } else {
+        body = await resp.text();
+      }
+      return JSON.stringify({
+        status: resp.status,
+        contentType,
+        body
+      });
+    } catch (e) {
+      return JSON.stringify({ error: e.message });
+    }
+  })()`;
+}
+async function fetchCommand(url, options = {}) {
+  if (!url) {
+    throw new Error(
+      "\u7F3A\u5C11 URL \u53C2\u6570\n  \u7528\u6CD5: bb-browser fetch <url> [--json] [--method POST] [--body '{...}']\n  \u793A\u4F8B: bb-browser fetch https://www.reddit.com/api/me.json --json"
+    );
+  }
+  await ensureDaemonRunning();
+  const isAbsolute = url.startsWith("http://") || url.startsWith("https://");
+  let targetTabId = options.tabId;
+  if (isAbsolute) {
+    let origin;
+    let hostname;
+    try {
+      const parsed = new URL(url);
+      origin = parsed.origin;
+      hostname = parsed.hostname;
+    } catch {
+      throw new Error(`\u65E0\u6548\u7684 URL: ${url}`);
+    }
+    if (!targetTabId) {
+      targetTabId = await ensureTabForOrigin(origin, hostname);
+    }
+  }
+  const script = buildFetchScript(url, options);
+  const evalReq = { id: generateId(), action: "eval", script, tabId: targetTabId };
+  const evalResp = await sendCommand(evalReq);
+  if (!evalResp.success) {
+    throw new Error(`Fetch \u5931\u8D25: ${evalResp.error}`);
+  }
+  const rawResult = evalResp.data?.result;
+  if (rawResult === void 0 || rawResult === null) {
+    throw new Error("Fetch \u672A\u8FD4\u56DE\u7ED3\u679C");
+  }
+  let result;
+  try {
+    result = typeof rawResult === "string" ? JSON.parse(rawResult) : rawResult;
+  } catch {
+    console.log(rawResult);
+    return;
+  }
+  if (result.error) {
+    throw new Error(`Fetch error: ${result.error}`);
+  }
+  if (options.output) {
+    const { writeFileSync } = await import("fs");
+    const content = typeof result.body === "object" ? JSON.stringify(result.body, null, 2) : String(result.body);
+    writeFileSync(options.output, content, "utf-8");
+    console.log(`\u5DF2\u5199\u5165 ${options.output} (${result.status}, ${content.length} bytes)`);
+    return;
+  }
+  if (typeof result.body === "object") {
+    console.log(JSON.stringify(result.body, null, 2));
+  } else {
+    console.log(result.body);
+  }
+}
+
+// packages/cli/src/commands/site.ts
+import { readFileSync, readdirSync, existsSync as existsSync2, mkdirSync } from "fs";
+import { join, relative } from "path";
+import { homedir } from "os";
+import { execSync } from "child_process";
+var BB_DIR = join(homedir(), ".bb-browser");
+var LOCAL_SITES_DIR = join(BB_DIR, "sites");
+var COMMUNITY_SITES_DIR = join(BB_DIR, "bb-sites");
+var COMMUNITY_REPO = "https://github.com/epiral/bb-sites.git";
+function parseSiteMeta(filePath, source) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const sitesDir = source === "local" ? LOCAL_SITES_DIR : COMMUNITY_SITES_DIR;
+  const relPath = relative(sitesDir, filePath);
+  const defaultName = relPath.replace(/\.js$/, "").replace(/\\/g, "/");
+  const metaMatch = content.match(/\/\*\s*@meta\s*\n([\s\S]*?)\*\//);
+  if (metaMatch) {
+    try {
+      const metaJson = JSON.parse(metaMatch[1]);
+      return {
+        name: metaJson.name || defaultName,
+        description: metaJson.description || "",
+        domain: metaJson.domain || "",
+        args: metaJson.args || {},
+        capabilities: metaJson.capabilities,
+        readOnly: metaJson.readOnly,
+        example: metaJson.example,
+        filePath,
+        source
+      };
+    } catch {
+    }
+  }
+  const meta = {
+    name: defaultName,
+    description: "",
+    domain: "",
+    args: {},
+    filePath,
+    source
+  };
+  const tagPattern = /\/\/\s*@(\w+)[ \t]+(.*)/g;
+  let match;
+  while ((match = tagPattern.exec(content)) !== null) {
+    const [, key, value] = match;
+    switch (key) {
+      case "name":
+        meta.name = value.trim();
+        break;
+      case "description":
+        meta.description = value.trim();
+        break;
+      case "domain":
+        meta.domain = value.trim();
+        break;
+      case "args":
+        for (const arg of value.trim().split(/[,\s]+/).filter(Boolean)) {
+          meta.args[arg] = { required: true };
+        }
+        break;
+      case "example":
+        meta.example = value.trim();
+        break;
+    }
+  }
+  return meta;
+}
+function scanSites(dir, source) {
+  if (!existsSync2(dir)) return [];
+  const sites = [];
+  function walk(currentDir) {
+    let entries;
+    try {
+      entries = readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        walk(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".js")) {
+        const meta = parseSiteMeta(fullPath, source);
+        if (meta) sites.push(meta);
+      }
+    }
+  }
+  walk(dir);
+  return sites;
+}
+function getAllSites() {
+  const community = scanSites(COMMUNITY_SITES_DIR, "community");
+  const local = scanSites(LOCAL_SITES_DIR, "local");
+  const byName = /* @__PURE__ */ new Map();
+  for (const s of community) byName.set(s.name, s);
+  for (const s of local) byName.set(s.name, s);
+  return Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+function matchTabOrigin2(tabUrl, domain) {
+  try {
+    const tabOrigin = new URL(tabUrl).hostname;
+    return tabOrigin === domain || tabOrigin.endsWith("." + domain);
+  } catch {
+    return false;
+  }
+}
+function siteList(options) {
+  const sites = getAllSites();
+  if (sites.length === 0) {
+    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}`);
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(sites.map((s) => ({
+      name: s.name,
+      description: s.description,
+      domain: s.domain,
+      args: s.args,
+      source: s.source
+    })), null, 2));
+    return;
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of sites) {
+    const platform = s.name.split("/")[0];
+    if (!groups.has(platform)) groups.set(platform, []);
+    groups.get(platform).push(s);
+  }
+  for (const [platform, items] of groups) {
+    console.log(`
+${platform}/`);
+    for (const s of items) {
+      const cmd = s.name.split("/").slice(1).join("/");
+      const src = s.source === "local" ? " (local)" : "";
+      const desc = s.description ? ` - ${s.description}` : "";
+      console.log(`  ${cmd.padEnd(20)}${desc}${src}`);
+    }
+  }
+  console.log();
+}
+function siteSearch(query, options) {
+  const sites = getAllSites();
+  const q = query.toLowerCase();
+  const matches = sites.filter(
+    (s) => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q) || s.domain.toLowerCase().includes(q)
+  );
+  if (matches.length === 0) {
+    console.log(`\u672A\u627E\u5230\u5339\u914D "${query}" \u7684 adapter\u3002`);
+    console.log("  \u67E5\u770B\u6240\u6709: bb-browser site list");
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(matches.map((s) => ({
+      name: s.name,
+      description: s.description,
+      domain: s.domain,
+      source: s.source
+    })), null, 2));
+    return;
+  }
+  for (const s of matches) {
+    const src = s.source === "local" ? " (local)" : "";
+    console.log(`${s.name.padEnd(24)} ${s.description}${src}`);
+  }
+}
+function siteUpdate() {
+  mkdirSync(BB_DIR, { recursive: true });
+  if (existsSync2(join(COMMUNITY_SITES_DIR, ".git"))) {
+    console.log("\u66F4\u65B0\u793E\u533A site adapter \u5E93...");
+    try {
+      execSync("git pull --ff-only", { cwd: COMMUNITY_SITES_DIR, stdio: "pipe" });
+      console.log("\u66F4\u65B0\u5B8C\u6210\u3002");
+    } catch (e) {
+      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}`);
+    try {
+      execSync(`git clone ${COMMUNITY_REPO} ${COMMUNITY_SITES_DIR}`, { stdio: "pipe" });
+      console.log("\u514B\u9686\u5B8C\u6210\u3002");
+    } catch (e) {
+      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");
+  console.log(`\u5DF2\u5B89\u88C5 ${sites.length} \u4E2A\u793E\u533A adapter\u3002`);
+}
+async function siteRun(name, args, options) {
+  const sites = getAllSites();
+  const site = sites.find((s) => s.name === name);
+  if (!site) {
+    const fuzzy = sites.filter((s) => s.name.includes(name));
+    console.error(`[error] site: "${name}" not found.`);
+    if (fuzzy.length > 0) {
+      console.error("  Did you mean:");
+      for (const s of fuzzy.slice(0, 5)) {
+        console.error(`    bb-browser site ${s.name}`);
+      }
+    } else {
+      console.error("  Try: bb-browser site list");
+      console.error("  Or:  bb-browser site update");
+    }
+    process.exit(1);
+  }
+  const argNames = Object.keys(site.args);
+  const argMap = {};
+  const positionalArgs = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith("--")) {
+      const flagName = args[i].slice(2);
+      if (flagName in site.args && args[i + 1]) {
+        argMap[flagName] = args[i + 1];
+        i++;
+      }
+    } else {
+      positionalArgs.push(args[i]);
+    }
+  }
+  let posIdx = 0;
+  for (const argName of argNames) {
+    if (!argMap[argName] && posIdx < positionalArgs.length) {
+      argMap[argName] = positionalArgs[posIdx++];
+    }
+  }
+  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(" ");
+      console.error(`  Usage: bb-browser site ${name} ${usage}`);
+      if (site.example) console.error(`  Example: ${site.example}`);
+      process.exit(1);
+    }
+  }
+  const jsContent = readFileSync(site.filePath, "utf-8");
+  const jsBody = jsContent.replace(/\/\*\s*@meta[\s\S]*?\*\//, "").trim();
+  const argsJson = JSON.stringify(argMap);
+  const script = `(${jsBody})(${argsJson})`;
+  await ensureDaemonRunning();
+  let targetTabId = options.tabId;
+  if (!targetTabId && site.domain) {
+    const listReq = { id: generateId(), action: "tab_list" };
+    const listResp = await sendCommand(listReq);
+    if (listResp.success && listResp.data?.tabs) {
+      const matchingTab = listResp.data.tabs.find(
+        (tab) => matchTabOrigin2(tab.url, site.domain)
+      );
+      if (matchingTab) {
+        targetTabId = matchingTab.tabId;
+      }
+    }
+    if (!targetTabId) {
+      const newResp = await sendCommand({
+        id: generateId(),
+        action: "tab_new",
+        url: `https://${site.domain}`
+      });
+      targetTabId = newResp.data?.tabId;
+      await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+    }
+  }
+  const evalReq = { id: generateId(), action: "eval", script, tabId: targetTabId };
+  const evalResp = await sendCommand(evalReq);
+  if (!evalResp.success) {
+    console.error(`[error] site ${name}: eval failed.`);
+    console.error(`  ${evalResp.error}`);
+    console.error(`  Check: is ${site.domain} open and logged in?`);
+    process.exit(1);
+  }
+  const result = evalResp.data?.result;
+  if (result === void 0 || result === null) {
+    if (options.json) {
+      console.log(JSON.stringify({ id: evalReq.id, success: true, data: null }));
+    } else {
+      console.log("(no output)");
+    }
+    return;
+  }
+  let parsed;
+  try {
+    parsed = typeof result === "string" ? JSON.parse(result) : result;
+  } catch {
+    parsed = result;
+  }
+  if (typeof parsed === "object" && parsed !== null && "error" in parsed) {
+    const errObj = parsed;
+    if (options.json) {
+      console.log(JSON.stringify({ id: evalReq.id, success: false, error: errObj.error, hint: errObj.hint }));
+    } else {
+      console.error(`[error] site ${name}: ${errObj.error}`);
+      if (errObj.hint) console.error(`  Hint: ${errObj.hint}`);
+    }
+    process.exit(1);
+  }
+  if (options.json) {
+    console.log(JSON.stringify({ id: evalReq.id, success: true, data: parsed }));
+  } else {
+    console.log(JSON.stringify(parsed, null, 2));
+  }
+}
+async function siteCommand(args, options = {}) {
+  const subCommand = args[0];
+  if (!subCommand || subCommand === "--help" || subCommand === "-h") {
+    console.log(`bb-browser site - \u7F51\u7AD9 CLI \u5316\uFF08\u7BA1\u7406\u548C\u8FD0\u884C site adapter\uFF09
+
+\u7528\u6CD5:
+  bb-browser site list                      \u5217\u51FA\u6240\u6709\u53EF\u7528 adapter
+  bb-browser site search <query>            \u641C\u7D22 adapter
+  bb-browser site <name> [args...]          \u8FD0\u884C adapter\uFF08\u7B80\u5199\uFF09
+  bb-browser site run <name> [args...]      \u8FD0\u884C adapter
+  bb-browser site update                    \u66F4\u65B0\u793E\u533A adapter \u5E93 (git clone/pull)
+
+\u76EE\u5F55:
+  ${LOCAL_SITES_DIR}      \u79C1\u6709 adapter\uFF08\u4F18\u5148\uFF09
+  ${COMMUNITY_SITES_DIR}   \u793E\u533A adapter
+
+\u793A\u4F8B:
+  bb-browser site update
+  bb-browser site list
+  bb-browser site reddit/thread https://www.reddit.com/r/LocalLLaMA/comments/...
+  bb-browser site twitter/user yan5xu
+  bb-browser site search reddit`);
+    return;
+  }
+  switch (subCommand) {
+    case "list":
+      siteList(options);
+      break;
+    case "search":
+      if (!args[1]) {
+        console.error("[error] site search: <query> is required.");
+        console.error("  Usage: bb-browser site search <query>");
+        process.exit(1);
+      }
+      siteSearch(args[1], options);
+      break;
+    case "update":
+      siteUpdate();
+      break;
+    case "run":
+      if (!args[1]) {
+        console.error("[error] site run: <name> is required.");
+        console.error("  Usage: bb-browser site run <name> [args...]");
+        console.error("  Try: bb-browser site list");
+        process.exit(1);
+      }
+      await siteRun(args[1], args.slice(2), options);
+      break;
+    default:
+      if (subCommand.includes("/")) {
+        await siteRun(subCommand, args.slice(1), options);
+      } else {
+        console.error(`[error] site: unknown subcommand "${subCommand}".`);
+        console.error("  Available: list, search, run, update");
+        console.error("  Try: bb-browser site --help");
+        process.exit(1);
+      }
+      break;
+  }
+}
+
 // packages/cli/src/index.ts
 var VERSION = "0.3.0";
 var HELP_TEXT = `
@@ -1480,6 +1998,12 @@ bb-browser - AI Agent \u6D4F\u89C8\u5668\u81EA\u52A8\u5316\u5DE5\u5177
   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
+  fetch <url>       \u5728\u6D4F\u89C8\u5668\u4E0A\u4E0B\u6587\u4E2D fetch\uFF08\u81EA\u52A8\u540C\u6E90\u8DEF\u7531\uFF0C\u5E26\u767B\u5F55\u6001\uFF09
+  site              \u7F51\u7AD9 CLI \u5316 \u2014 \u7BA1\u7406\u548C\u8FD0\u884C site adapter
+  site list         \u5217\u51FA\u6240\u6709\u53EF\u7528 adapter
+  site search <q>   \u641C\u7D22 adapter
+  site <name>       \u8FD0\u884C adapter\uFF08\u5982 site reddit/thread <url>\uFF09
+  site update       \u66F4\u65B0\u793E\u533A adapter \u5E93
 
 \u9009\u9879\uFF1A
   --json          \u4EE5 JSON \u683C\u5F0F\u8F93\u51FA
@@ -1488,6 +2012,7 @@ bb-browser - AI Agent \u6D4F\u89C8\u5668\u81EA\u52A8\u5316\u5DE5\u5177
   -d, --depth <n> \u9650\u5236\u6811\u6DF1\u5EA6\uFF08snapshot \u547D\u4EE4\uFF09
   -s, --selector <sel> \u9650\u5B9A CSS \u9009\u62E9\u5668\u8303\u56F4\uFF08snapshot \u547D\u4EE4\uFF09
   --tab <tabId>   \u6307\u5B9A\u64CD\u4F5C\u7684\u6807\u7B7E\u9875 ID
+  --mcp           \u542F\u52A8 MCP server\uFF08\u7528\u4E8E Claude Code / Cursor \u7B49 AI \u5DE5\u5177\uFF09
   --help, -h      \u663E\u793A\u5E2E\u52A9\u4FE1\u606F
   --version, -v   \u663E\u793A\u7248\u672C\u53F7
 
@@ -1547,7 +2072,7 @@ function parseArgs(argv) {
       }
     } else if (arg === "--id") {
       skipNext = true;
-    } else if (arg === "--tab" && !result.command) {
+    } else if (arg === "--tab") {
       skipNext = true;
     } else if (arg.startsWith("-")) {
     } else if (result.command === null) {
@@ -1566,6 +2091,13 @@ async function main() {
     console.log(VERSION);
     return;
   }
+  if (process.argv.includes("--mcp")) {
+    const mcpPath = new URL("./mcp.js", import.meta.url).pathname;
+    const { spawn: spawn3 } = await import("child_process");
+    const child = spawn3(process.execPath, [mcpPath], { stdio: "inherit" });
+    child.on("exit", (code) => process.exit(code ?? 0));
+    return;
+  }
   if (parsed.flags.help || !parsed.command) {
     console.log(HELP_TEXT);
     return;
@@ -1724,7 +2256,9 @@ async function main() {
       }
       case "daemon":
       case "start": {
-        await daemonCommand({ json: parsed.flags.json });
+        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": {
@@ -1835,9 +2369,10 @@ async function main() {
         const subCommand = parsed.args[0] || "requests";
         const urlOrFilter = parsed.args[1];
         const abort = process.argv.includes("--abort");
+        const withBody = process.argv.includes("--with-body");
         const bodyIndex = process.argv.findIndex((a) => a === "--body");
         const body = bodyIndex >= 0 ? process.argv[bodyIndex + 1] : void 0;
-        await networkCommand(subCommand, urlOrFilter, { json: parsed.flags.json, abort, body, tabId: globalTabId });
+        await networkCommand(subCommand, urlOrFilter, { json: parsed.flags.json, abort, body, withBody, tabId: globalTabId });
         break;
       }
       case "console": {
@@ -1863,6 +2398,36 @@ async function main() {
         await traceCommand(subCmd, { json: parsed.flags.json, tabId: globalTabId });
         break;
       }
+      case "fetch": {
+        const fetchUrl = parsed.args[0];
+        if (!fetchUrl) {
+          console.error("[error] fetch: <url> is required.");
+          console.error("  Usage: bb-browser fetch <url> [--json] [--method POST] [--body '{...}']");
+          console.error("  Example: bb-browser fetch https://www.reddit.com/api/me.json --json");
+          process.exit(1);
+        }
+        const methodIdx = process.argv.findIndex((a) => a === "--method");
+        const fetchMethod = methodIdx >= 0 ? process.argv[methodIdx + 1] : void 0;
+        const fetchBodyIdx = process.argv.findIndex((a) => a === "--body");
+        const fetchBody = fetchBodyIdx >= 0 ? process.argv[fetchBodyIdx + 1] : void 0;
+        const headersIdx = process.argv.findIndex((a) => a === "--headers");
+        const fetchHeaders = headersIdx >= 0 ? process.argv[headersIdx + 1] : void 0;
+        const outputIdx = process.argv.findIndex((a) => a === "--output");
+        const fetchOutput = outputIdx >= 0 ? process.argv[outputIdx + 1] : void 0;
+        await fetchCommand(fetchUrl, {
+          json: parsed.flags.json,
+          method: fetchMethod,
+          body: fetchBody,
+          headers: fetchHeaders,
+          output: fetchOutput,
+          tabId: globalTabId
+        });
+        break;
+      }
+      case "site": {
+        await siteCommand(parsed.args, { json: parsed.flags.json, tabId: globalTabId });
+        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");