bb-browser-api 0.11.5

package/dist/daemon.js

@@ -0,0 +1,2472 @@
+#!/usr/bin/env node
+import {
+  COMMAND_TIMEOUT,
+  DAEMON_HOST,
+  DAEMON_PORT
+} from "./chunk-CRK6CV23.js";
+import "./chunk-ERAIAHQ5.js";
+import "./chunk-D4HDZEJT.js";
+
+// packages/daemon/src/index.ts
+import { parseArgs } from "util";
+import { writeFileSync, unlinkSync, existsSync, readFileSync as readFileSync2 } from "fs";
+import { mkdirSync } from "fs";
+import { randomBytes } from "crypto";
+import os from "os";
+import path2 from "path";
+
+// packages/daemon/src/http-server.ts
+import { createServer } from "http";
+
+// packages/daemon/src/command-dispatch.ts
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function buildRequestError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function ok(id, data) {
+  return { id, success: true, data };
+}
+function fail(id, error) {
+  return { id, success: false, error: buildRequestError(error).message };
+}
+var cachedBuildDomTreeScript = null;
+function loadBuildDomTreeScript() {
+  if (cachedBuildDomTreeScript) return cachedBuildDomTreeScript;
+  const currentDir = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    // Built dist: dist/daemon.js → ../packages/shared/buildDomTree.js
+    path.resolve(currentDir, "../packages/shared/buildDomTree.js"),
+    // Dev mode: packages/daemon/src/ → ../../shared/buildDomTree.js
+    path.resolve(currentDir, "../../shared/buildDomTree.js"),
+    // npm installed: dist/daemon.js → same level
+    path.resolve(currentDir, "./buildDomTree.js"),
+    path.resolve(currentDir, "../buildDomTree.js")
+  ];
+  for (const candidate of candidates) {
+    try {
+      cachedBuildDomTreeScript = readFileSync(candidate, "utf8");
+      return cachedBuildDomTreeScript;
+    } catch {
+    }
+  }
+  throw new Error("Cannot find buildDomTree.js");
+}
+function convertBuildDomTreeResult(result, options) {
+  const { interactiveOnly, compact, maxDepth, selector } = options;
+  const { rootId, map } = result;
+  const refs = {};
+  const lines = [];
+  const getRole = (node) => {
+    const tagName = node.tagName.toLowerCase();
+    const role = node.attributes?.role;
+    if (role) return role;
+    const type = node.attributes?.type?.toLowerCase() || "text";
+    const inputRoleMap = {
+      text: "textbox",
+      password: "textbox",
+      email: "textbox",
+      url: "textbox",
+      tel: "textbox",
+      search: "searchbox",
+      number: "spinbutton",
+      range: "slider",
+      checkbox: "checkbox",
+      radio: "radio",
+      button: "button",
+      submit: "button",
+      reset: "button",
+      file: "button"
+    };
+    const roleMap = {
+      a: "link",
+      button: "button",
+      input: inputRoleMap[type] || "textbox",
+      select: "combobox",
+      textarea: "textbox",
+      img: "image",
+      nav: "navigation",
+      main: "main",
+      header: "banner",
+      footer: "contentinfo",
+      aside: "complementary",
+      form: "form",
+      table: "table",
+      ul: "list",
+      ol: "list",
+      li: "listitem",
+      h1: "heading",
+      h2: "heading",
+      h3: "heading",
+      h4: "heading",
+      h5: "heading",
+      h6: "heading",
+      dialog: "dialog",
+      article: "article",
+      section: "region",
+      label: "label",
+      details: "group",
+      summary: "button"
+    };
+    return roleMap[tagName] || tagName;
+  };
+  const collectTextContent = (node, nodeMap, depthLimit = 5) => {
+    const texts = [];
+    const visit = (nodeId, depth) => {
+      if (depth > depthLimit) return;
+      const currentNode = nodeMap[nodeId];
+      if (!currentNode) return;
+      if ("type" in currentNode && currentNode.type === "TEXT_NODE") {
+        const text = currentNode.text.trim();
+        if (text) texts.push(text);
+        return;
+      }
+      for (const childId of currentNode.children || []) visit(childId, depth + 1);
+    };
+    for (const childId of node.children || []) visit(childId, 0);
+    return texts.join(" ").trim();
+  };
+  const getName = (node) => {
+    const attrs = node.attributes || {};
+    return attrs["aria-label"] || attrs.title || attrs.placeholder || attrs.alt || attrs.value || collectTextContent(node, map) || attrs.name || void 0;
+  };
+  const truncateText = (text, length = 50) => text.length <= length ? text : `${text.slice(0, length - 3)}...`;
+  const selectorText = selector?.trim().toLowerCase();
+  const matchesSelector = (node, role, name) => {
+    if (!selectorText) return true;
+    const haystack = [node.tagName, role, name, node.xpath || "", ...Object.values(node.attributes || {})].join(" ").toLowerCase();
+    return haystack.includes(selectorText);
+  };
+  if (interactiveOnly) {
+    const interactiveNodes = Object.entries(map).filter(([, node]) => !("type" in node) && node.highlightIndex !== void 0 && node.highlightIndex !== null).map(([id, node]) => ({ id, node })).sort((a, b) => (a.node.highlightIndex ?? 0) - (b.node.highlightIndex ?? 0));
+    for (const { node } of interactiveNodes) {
+      const refId = String(node.highlightIndex);
+      const role = getRole(node);
+      const name = getName(node);
+      if (!matchesSelector(node, role, name)) continue;
+      let line = `${role} [ref=${refId}]`;
+      if (name) line += ` ${JSON.stringify(truncateText(name))}`;
+      lines.push(line);
+      refs[refId] = { xpath: node.xpath || "", role, name, tagName: node.tagName.toLowerCase() };
+    }
+    return { snapshot: lines.join("\n"), refs };
+  }
+  const walk = (nodeId, depth) => {
+    if (maxDepth !== void 0 && depth > maxDepth) return;
+    const node = map[nodeId];
+    if (!node) return;
+    if ("type" in node && node.type === "TEXT_NODE") {
+      const text = node.text.trim();
+      if (!text) return;
+      lines.push(`${"  ".repeat(depth)}- text ${JSON.stringify(truncateText(text, compact ? 80 : 120))}`);
+      return;
+    }
+    const el = node;
+    const role = getRole(el);
+    const name = getName(el);
+    if (!matchesSelector(el, role, name)) {
+      for (const childId of el.children || []) walk(childId, depth + 1);
+      return;
+    }
+    const indent = "  ".repeat(depth);
+    const refId = el.highlightIndex !== void 0 && el.highlightIndex !== null ? String(el.highlightIndex) : null;
+    let line = `${indent}- ${role}`;
+    if (refId) line += ` [ref=${refId}]`;
+    if (name) line += ` ${JSON.stringify(truncateText(name, compact ? 50 : 80))}`;
+    if (!compact) line += ` <${el.tagName.toLowerCase()}>`;
+    lines.push(line);
+    if (refId) {
+      refs[refId] = { xpath: el.xpath || "", role, name, tagName: el.tagName.toLowerCase() };
+    }
+    for (const childId of el.children || []) walk(childId, depth + 1);
+  };
+  walk(rootId, 0);
+  return { snapshot: lines.join("\n"), refs };
+}
+var CLEANUP_HIGHLIGHTS_SCRIPT = `(() => {
+  if (window._highlightCleanupFunctions && window._highlightCleanupFunctions.length) {
+    window._highlightCleanupFunctions.forEach(fn => { try { fn(); } catch {} });
+    window._highlightCleanupFunctions = [];
+  }
+  const c = document.getElementById('playwright-highlight-container');
+  if (c) c.remove();
+})()`;
+async function buildSnapshot(cdp, targetId, tab, request) {
+  const script = loadBuildDomTreeScript();
+  const buildArgs = {
+    showHighlightElements: true,
+    focusHighlightIndex: -1,
+    viewportExpansion: -1,
+    debugMode: false,
+    startId: 0,
+    startHighlightIndex: 0
+  };
+  const expression = `(() => { ${script}; const fn = globalThis.buildDomTree ?? (typeof window !== 'undefined' ? window.buildDomTree : undefined); if (typeof fn !== 'function') { throw new Error('buildDomTree is not available after script injection'); } return fn(${JSON.stringify(buildArgs)}); })()`;
+  const value = await cdp.evaluate(targetId, expression, true);
+  if (!value || !value.map || !value.rootId) {
+    const title = await cdp.evaluate(targetId, "document.title", true);
+    const pageUrl = await cdp.evaluate(targetId, "location.href", true);
+    tab.refs = {};
+    return { snapshot: title || pageUrl, refs: {} };
+  }
+  const snapshot = convertBuildDomTreeResult(value, {
+    interactiveOnly: !!request.interactive,
+    compact: !!request.compact,
+    maxDepth: request.maxDepth,
+    selector: request.selector
+  });
+  tab.refs = snapshot.refs || {};
+  return snapshot;
+}
+async function resolveBackendNodeIdByXPath(cdp, targetId, xpath) {
+  await cdp.sessionCommand(targetId, "DOM.getDocument", { depth: 0 });
+  const search = await cdp.sessionCommand(
+    targetId,
+    "DOM.performSearch",
+    { query: xpath, includeUserAgentShadowDOM: true }
+  );
+  try {
+    if (!search.resultCount) {
+      throw new Error(`Unknown ref xpath: ${xpath}`);
+    }
+    const { nodeIds } = await cdp.sessionCommand(
+      targetId,
+      "DOM.getSearchResults",
+      { searchId: search.searchId, fromIndex: 0, toIndex: search.resultCount }
+    );
+    for (const nodeId of nodeIds) {
+      const described = await cdp.sessionCommand(targetId, "DOM.describeNode", { nodeId });
+      if (described.node.backendNodeId) {
+        return described.node.backendNodeId;
+      }
+    }
+    throw new Error(`XPath resolved but no backend node id found: ${xpath}`);
+  } finally {
+    await cdp.sessionCommand(targetId, "DOM.discardSearchResults", { searchId: search.searchId }).catch(() => {
+    });
+  }
+}
+async function parseRef(cdp, targetId, tab, ref) {
+  const found = tab.refs[ref];
+  if (!found) {
+    throw new Error(`Unknown ref: ${ref}. Run snapshot first.`);
+  }
+  if (found.backendDOMNodeId) {
+    return found.backendDOMNodeId;
+  }
+  if (found.xpath) {
+    const backendDOMNodeId = await resolveBackendNodeIdByXPath(cdp, targetId, found.xpath);
+    found.backendDOMNodeId = backendDOMNodeId;
+    return backendDOMNodeId;
+  }
+  throw new Error(`Unknown ref: ${ref}. Run snapshot first.`);
+}
+async function getInteractablePoint(cdp, targetId, backendNodeId) {
+  const resolved = await cdp.sessionCommand(
+    targetId,
+    "DOM.resolveNode",
+    { backendNodeId }
+  );
+  const call = await cdp.sessionCommand(targetId, "Runtime.callFunctionOn", {
+    objectId: resolved.object.objectId,
+    functionDeclaration: `function() {
+      if (!(this instanceof Element)) {
+        throw new Error('Ref does not resolve to an element');
+      }
+      this.scrollIntoView({ behavior: 'auto', block: 'center', inline: 'center' });
+      const rect = this.getBoundingClientRect();
+      if (!rect || rect.width <= 0 || rect.height <= 0) {
+        throw new Error('Element is not visible');
+      }
+      return {
+        x: rect.left + rect.width / 2,
+        y: rect.top + rect.height / 2,
+      };
+    }`,
+    returnByValue: true
+  });
+  if (call.exceptionDetails) {
+    throw new Error(call.exceptionDetails.text || "Failed to resolve element point");
+  }
+  const point = call.result.value;
+  if (!point || typeof point.x !== "number" || typeof point.y !== "number" || !Number.isFinite(point.x) || !Number.isFinite(point.y)) {
+    throw new Error("Failed to resolve element point");
+  }
+  return point;
+}
+async function mouseClick(cdp, targetId, x, y) {
+  await cdp.sessionCommand(targetId, "Input.dispatchMouseEvent", {
+    type: "mouseMoved",
+    x,
+    y,
+    button: "none"
+  });
+  await cdp.sessionCommand(targetId, "Input.dispatchMouseEvent", {
+    type: "mousePressed",
+    x,
+    y,
+    button: "left",
+    clickCount: 1
+  });
+  await cdp.sessionCommand(targetId, "Input.dispatchMouseEvent", {
+    type: "mouseReleased",
+    x,
+    y,
+    button: "left",
+    clickCount: 1
+  });
+}
+async function insertTextIntoNode(cdp, targetId, backendNodeId, text, clearFirst) {
+  const resolved = await cdp.sessionCommand(
+    targetId,
+    "DOM.resolveNode",
+    { backendNodeId }
+  );
+  await cdp.sessionCommand(targetId, "Runtime.callFunctionOn", {
+    objectId: resolved.object.objectId,
+    functionDeclaration: `function(clearFirst) {
+      if (typeof this.scrollIntoView === 'function') {
+        this.scrollIntoView({ behavior: 'auto', block: 'center', inline: 'center' });
+      }
+      if (typeof this.focus === 'function') this.focus();
+      if (this instanceof HTMLInputElement || this instanceof HTMLTextAreaElement) {
+        if (clearFirst) {
+          this.value = '';
+          this.dispatchEvent(new Event('input', { bubbles: true }));
+        }
+        if (typeof this.setSelectionRange === 'function') {
+          const end = this.value.length;
+          this.setSelectionRange(end, end);
+        }
+        return true;
+      }
+      if (this instanceof HTMLElement && this.isContentEditable) {
+        if (clearFirst) {
+          this.textContent = '';
+          this.dispatchEvent(new Event('input', { bubbles: true }));
+        }
+        const selection = window.getSelection();
+        if (selection) {
+          const range = document.createRange();
+          range.selectNodeContents(this);
+          range.collapse(false);
+          selection.removeAllRanges();
+          selection.addRange(range);
+        }
+        return true;
+      }
+      return false;
+    }`,
+    arguments: [{ value: clearFirst }],
+    returnByValue: true
+  });
+  if (text) {
+    await cdp.sessionCommand(targetId, "DOM.focus", { backendNodeId });
+    await cdp.sessionCommand(targetId, "Input.insertText", { text });
+  }
+}
+async function getAttributeValue(cdp, targetId, backendNodeId, attribute) {
+  if (attribute === "text") {
+    const resolved = await cdp.sessionCommand(
+      targetId,
+      "DOM.resolveNode",
+      { backendNodeId }
+    );
+    const call2 = await cdp.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 cdp.sessionCommand(
+    targetId,
+    "DOM.resolveNode",
+    { backendNodeId }
+  );
+  const call = await cdp.sessionCommand(
+    targetId,
+    "Runtime.callFunctionOn",
+    {
+      objectId: result.object.objectId,
+      functionDeclaration: `function() { if (${JSON.stringify(attribute)} === 'url') return this.href || this.src || location.href; if (${JSON.stringify(attribute)} === 'title') return document.title; return this.getAttribute(${JSON.stringify(attribute)}) || ''; }`,
+      returnByValue: true
+    }
+  );
+  return String(call.result.value ?? "");
+}
+var traceRecording = false;
+var traceEvents = [];
+async function dispatchRequest(cdp, request) {
+  const tabRef = request.tabId;
+  if (request.action === "tab_new") {
+    const url = request.url ?? "about:blank";
+    const created = await cdp.browserCommand(
+      "Target.createTarget",
+      { url, background: true }
+    );
+    await cdp.attachAndEnable(created.targetId);
+    const newTab = cdp.tabManager.getTab(created.targetId);
+    return ok(request.id, {
+      tabId: created.targetId,
+      url,
+      tab: newTab?.shortId ?? created.targetId.slice(-4).toLowerCase(),
+      seq: newTab?.recordAction()
+    });
+  }
+  const target = await cdp.ensurePageTarget(
+    tabRef !== void 0 ? String(tabRef) : void 0
+  );
+  const tab = cdp.tabManager.getTab(target.id);
+  if (!tab) throw new Error("Internal error: tab state not found");
+  const shortId = tab.shortId;
+  switch (request.action) {
+    // -----------------------------------------------------------------------
+    // Navigation
+    // -----------------------------------------------------------------------
+    case "open": {
+      if (!request.url) return fail(request.id, "Missing url parameter");
+      const seq = tab.recordAction();
+      if (tabRef === void 0) {
+        const created = await cdp.browserCommand(
+          "Target.createTarget",
+          { url: request.url, background: true }
+        );
+        const newTarget = await cdp.ensurePageTarget(created.targetId);
+        const newTab = cdp.tabManager.getTab(newTarget.id);
+        return ok(request.id, {
+          url: request.url,
+          tabId: newTarget.id,
+          tab: newTab?.shortId ?? shortId,
+          seq
+        });
+      }
+      await cdp.pageCommand(target.id, "Page.navigate", { url: request.url });
+      tab.refs = {};
+      return ok(request.id, {
+        url: request.url,
+        title: target.title,
+        tabId: target.id,
+        tab: shortId,
+        seq
+      });
+    }
+    case "back": {
+      const seq = tab.recordAction();
+      await cdp.evaluate(target.id, "history.back(); undefined");
+      return ok(request.id, { tab: shortId, seq });
+    }
+    case "forward": {
+      const seq = tab.recordAction();
+      await cdp.evaluate(target.id, "history.forward(); undefined");
+      return ok(request.id, { tab: shortId, seq });
+    }
+    case "refresh": {
+      const seq = tab.recordAction();
+      await cdp.sessionCommand(target.id, "Page.reload", { ignoreCache: false });
+      return ok(request.id, { tab: shortId, seq });
+    }
+    case "close": {
+      const seq = tab.recordAction();
+      await cdp.browserCommand("Target.closeTarget", { targetId: target.id });
+      tab.refs = {};
+      return ok(request.id, { tab: shortId, seq });
+    }
+    // -----------------------------------------------------------------------
+    // Snapshot / observation
+    // -----------------------------------------------------------------------
+    case "snapshot": {
+      const snapshotData = await buildSnapshot(cdp, target.id, tab, request);
+      return ok(request.id, {
+        title: target.title,
+        url: target.url,
+        snapshotData,
+        tab: shortId
+      });
+    }
+    case "screenshot": {
+      await cdp.evaluate(target.id, CLEANUP_HIGHLIGHTS_SCRIPT, true).catch(() => {
+      });
+      const result = await cdp.sessionCommand(
+        target.id,
+        "Page.captureScreenshot",
+        { format: "png", fromSurface: true }
+      );
+      return ok(request.id, {
+        dataUrl: `data:image/png;base64,${result.data}`,
+        tab: shortId
+      });
+    }
+    // -----------------------------------------------------------------------
+    // Element interaction
+    // -----------------------------------------------------------------------
+    case "click":
+    case "hover": {
+      if (!request.ref) return fail(request.id, "Missing ref parameter");
+      const seq = tab.recordAction();
+      const backendNodeId = await parseRef(cdp, target.id, tab, request.ref);
+      const point = await getInteractablePoint(cdp, target.id, backendNodeId);
+      await cdp.sessionCommand(target.id, "Input.dispatchMouseEvent", {
+        type: "mouseMoved",
+        x: point.x,
+        y: point.y,
+        button: "none"
+      });
+      if (request.action === "click") {
+        await mouseClick(cdp, target.id, point.x, point.y);
+      }
+      return ok(request.id, { tab: shortId, seq });
+    }
+    case "fill":
+    case "type": {
+      if (!request.ref) return fail(request.id, "Missing ref parameter");
+      if (request.text == null) return fail(request.id, "Missing text parameter");
+      const seq = tab.recordAction();
+      const backendNodeId = await parseRef(cdp, target.id, tab, request.ref);
+      await insertTextIntoNode(cdp, target.id, backendNodeId, request.text, request.action === "fill");
+      return ok(request.id, {
+        value: request.text,
+        tab: shortId,
+        seq
+      });
+    }
+    case "check":
+    case "uncheck": {
+      if (!request.ref) return fail(request.id, "Missing ref parameter");
+      const seq = tab.recordAction();
+      const desired = request.action === "check";
+      const backendNodeId = await parseRef(cdp, target.id, tab, request.ref);
+      const resolved = await cdp.sessionCommand(
+        target.id,
+        "DOM.resolveNode",
+        { backendNodeId }
+      );
+      await cdp.sessionCommand(target.id, "Runtime.callFunctionOn", {
+        objectId: resolved.object.objectId,
+        functionDeclaration: `function() { this.checked = ${desired}; this.dispatchEvent(new Event('input', { bubbles: true })); this.dispatchEvent(new Event('change', { bubbles: true })); }`
+      });
+      return ok(request.id, { tab: shortId, seq });
+    }
+    case "select": {
+      if (!request.ref || request.value == null) return fail(request.id, "Missing ref or value parameter");
+      const seq = tab.recordAction();
+      const backendNodeId = await parseRef(cdp, target.id, tab, request.ref);
+      const resolved = await cdp.sessionCommand(
+        target.id,
+        "DOM.resolveNode",
+        { backendNodeId }
+      );
+      await cdp.sessionCommand(target.id, "Runtime.callFunctionOn", {
+        objectId: resolved.object.objectId,
+        functionDeclaration: `function() { this.value = ${JSON.stringify(request.value)}; this.dispatchEvent(new Event('input', { bubbles: true })); this.dispatchEvent(new Event('change', { bubbles: true })); }`
+      });
+      return ok(request.id, {
+        value: request.value,
+        tab: shortId,
+        seq
+      });
+    }
+    case "get": {
+      if (!request.attribute) return fail(request.id, "Missing attribute parameter");
+      if (request.attribute === "url" && !request.ref) {
+        return ok(request.id, {
+          value: await cdp.evaluate(target.id, "location.href", true),
+          tab: shortId
+        });
+      }
+      if (request.attribute === "title" && !request.ref) {
+        return ok(request.id, {
+          value: await cdp.evaluate(target.id, "document.title", true),
+          tab: shortId
+        });
+      }
+      if (!request.ref) return fail(request.id, "Missing ref parameter");
+      const value = await getAttributeValue(
+        cdp,
+        target.id,
+        await parseRef(cdp, target.id, tab, request.ref),
+        request.attribute
+      );
+      return ok(request.id, { value, tab: shortId });
+    }
+    case "press": {
+      if (!request.key) return fail(request.id, "Missing key parameter");
+      const seq = tab.recordAction();
+      await cdp.sessionCommand(target.id, "Input.dispatchKeyEvent", {
+        type: "keyDown",
+        key: request.key
+      });
+      if (request.key.length === 1) {
+        await cdp.sessionCommand(target.id, "Input.dispatchKeyEvent", {
+          type: "char",
+          text: request.key,
+          key: request.key
+        });
+      }
+      await cdp.sessionCommand(target.id, "Input.dispatchKeyEvent", {
+        type: "keyUp",
+        key: request.key
+      });
+      return ok(request.id, { tab: shortId, seq });
+    }
+    case "scroll": {
+      const seq = tab.recordAction();
+      const pixels = request.pixels ?? 300;
+      let deltaX = 0;
+      let deltaY = 0;
+      switch (request.direction) {
+        case "up":
+          deltaY = -pixels;
+          break;
+        case "down":
+          deltaY = pixels;
+          break;
+        case "left":
+          deltaX = -pixels;
+          break;
+        case "right":
+          deltaX = pixels;
+          break;
+      }
+      await cdp.sessionCommand(target.id, "Input.dispatchMouseEvent", {
+        type: "mouseWheel",
+        x: 0,
+        y: 0,
+        deltaX,
+        deltaY
+      });
+      return ok(request.id, { tab: shortId, seq });
+    }
+    case "wait": {
+      await new Promise((resolve) => setTimeout(resolve, request.ms ?? 1e3));
+      return ok(request.id, { tab: shortId });
+    }
+    case "eval": {
+      if (!request.script) return fail(request.id, "Missing script parameter");
+      const seq = tab.recordAction();
+      const result = await cdp.evaluate(target.id, request.script, true);
+      return ok(request.id, {
+        result,
+        tab: shortId,
+        seq
+      });
+    }
+    case "fetch": {
+      if (!request.url) return fail(request.id, "Missing url parameter");
+      const seq = tab.recordAction();
+      const method = (request.method || "GET").toUpperCase();
+      const hasBody = request.body && method !== "GET" && method !== "HEAD";
+      let headersExpr = "{}";
+      if (request.headers) {
+        headersExpr = JSON.stringify(request.headers);
+      }
+      const credentials = request.credentials || "omit";
+      const fetchScript = `(async () => {
+        try {
+          const resp = await fetch(${JSON.stringify(request.url)}, {
+            method: ${JSON.stringify(method)},
+            credentials: ${JSON.stringify(credentials)},
+            headers: ${headersExpr}${hasBody ? `,
+            body: ${JSON.stringify(request.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 {
+            status: resp.status,
+            contentType,
+            body
+          };
+        } catch (e) {
+          return { 
+            error: e.message,
+            errorName: e.name,
+            errorStack: e.stack,
+            currentUrl: location.href
+          };
+        }
+      })()`;
+      const result = await cdp.evaluate(
+        target.id,
+        fetchScript,
+        true
+      );
+      if (result?.error) {
+        const errorDetails = [
+          `Fetch error: ${result.error}`,
+          result.errorName ? `(${result.errorName})` : "",
+          result.currentUrl ? `from page: ${result.currentUrl}` : ""
+        ].filter(Boolean).join(" ");
+        return fail(request.id, errorDetails);
+      }
+      return ok(request.id, {
+        fetchResponse: {
+          status: result?.status ?? 0,
+          contentType: result?.contentType ?? "",
+          body: result?.body
+        },
+        tab: shortId,
+        seq
+      });
+    }
+    // -----------------------------------------------------------------------
+    // Tab management
+    // -----------------------------------------------------------------------
+    case "tab_list": {
+      const targets = (await cdp.getTargets()).filter((t) => t.type === "page");
+      const tabs = targets.map((t, index) => {
+        const tState = cdp.tabManager.getTab(t.id);
+        return {
+          index,
+          url: t.url,
+          title: t.title,
+          active: t.id === cdp.currentTargetId || !cdp.currentTargetId && index === 0,
+          tabId: t.id,
+          tab: tState?.shortId ?? t.id.slice(-4).toLowerCase()
+        };
+      });
+      return ok(request.id, {
+        tabs,
+        activeIndex: tabs.findIndex((t) => t.active)
+      });
+    }
+    // tab_new is handled before ensurePageTarget() above
+    case "tab_select": {
+      const targets = (await cdp.getTargets()).filter((t) => t.type === "page");
+      let selected;
+      if (request.tabId !== void 0) {
+        const tabIdStr = String(request.tabId);
+        const resolvedId = cdp.tabManager.resolveShortId(tabIdStr);
+        if (resolvedId) {
+          selected = targets.find((t) => t.id === resolvedId);
+        }
+        if (!selected) {
+          selected = targets.find((t) => t.id === tabIdStr);
+        }
+        if (!selected) {
+          const num = Number(tabIdStr);
+          if (!Number.isNaN(num)) {
+            selected = targets[num];
+          }
+        }
+      } else {
+        selected = targets[request.index ?? 0];
+      }
+      if (!selected) return fail(request.id, "Tab not found");
+      cdp.currentTargetId = selected.id;
+      await cdp.attachAndEnable(selected.id);
+      const selTab = cdp.tabManager.getTab(selected.id);
+      return ok(request.id, {
+        tabId: selected.id,
+        url: selected.url,
+        title: selected.title,
+        tab: selTab?.shortId
+      });
+    }
+    case "tab_close": {
+      const targets = (await cdp.getTargets()).filter((t) => t.type === "page");
+      let selected;
+      if (request.tabId !== void 0) {
+        const tabIdStr = String(request.tabId);
+        const resolvedId = cdp.tabManager.resolveShortId(tabIdStr);
+        if (resolvedId) {
+          selected = targets.find((t) => t.id === resolvedId);
+        }
+        if (!selected) {
+          selected = targets.find((t) => t.id === tabIdStr);
+        }
+        if (!selected) {
+          const num = Number(tabIdStr);
+          if (!Number.isNaN(num)) {
+            selected = targets[num];
+          }
+        }
+      } else {
+        selected = targets[request.index ?? 0];
+      }
+      if (!selected) return fail(request.id, "Tab not found");
+      const closedTab = cdp.tabManager.getTab(selected.id);
+      const closedShort = closedTab?.shortId;
+      await cdp.browserCommand("Target.closeTarget", { targetId: selected.id });
+      if (cdp.currentTargetId === selected.id) {
+        cdp.currentTargetId = void 0;
+      }
+      return ok(request.id, {
+        tabId: selected.id,
+        tab: closedShort
+      });
+    }
+    // -----------------------------------------------------------------------
+    // Frame navigation
+    // -----------------------------------------------------------------------
+    case "frame": {
+      if (!request.selector) return fail(request.id, "Missing selector parameter");
+      const seq = tab.recordAction();
+      const document = await cdp.pageCommand(
+        target.id,
+        "DOM.getDocument",
+        {}
+      );
+      const node = await cdp.pageCommand(
+        target.id,
+        "DOM.querySelector",
+        { nodeId: document.root.nodeId, selector: request.selector }
+      );
+      if (!node.nodeId) return fail(request.id, `iframe not found: ${request.selector}`);
+      const described = await cdp.pageCommand(target.id, "DOM.describeNode", { nodeId: node.nodeId });
+      const frameId = described.node.frameId;
+      const nodeName = String(described.node.nodeName ?? "").toLowerCase();
+      if (!frameId) return fail(request.id, `Cannot get iframe frameId: ${request.selector}`);
+      if (nodeName && nodeName !== "iframe" && nodeName !== "frame") {
+        return fail(request.id, `Element is not an iframe: ${nodeName}`);
+      }
+      tab.activeFrameId = frameId;
+      const attributes = described.node.attributes ?? [];
+      const attrMap = {};
+      for (let i = 0; i < attributes.length; i += 2) {
+        attrMap[String(attributes[i])] = String(attributes[i + 1] ?? "");
+      }
+      return ok(request.id, {
+        frameInfo: {
+          selector: request.selector,
+          name: attrMap.name ?? "",
+          url: attrMap.src ?? "",
+          frameId
+        },
+        tab: shortId,
+        seq
+      });
+    }
+    case "frame_main": {
+      const seq = tab.recordAction();
+      tab.activeFrameId = null;
+      return ok(request.id, {
+        frameInfo: { frameId: 0 },
+        tab: shortId,
+        seq
+      });
+    }
+    // -----------------------------------------------------------------------
+    // Dialog
+    // -----------------------------------------------------------------------
+    case "dialog": {
+      const seq = tab.recordAction();
+      tab.dialogHandler = {
+        accept: request.dialogResponse !== "dismiss",
+        ...request.promptText !== void 0 ? { promptText: request.promptText } : {}
+      };
+      await cdp.sessionCommand(target.id, "Page.enable");
+      return ok(request.id, {
+        dialogInfo: {
+          type: "armed",
+          message: `Dialog handler armed: ${request.dialogResponse ?? "accept"}`,
+          handled: false
+        },
+        tab: shortId,
+        seq
+      });
+    }
+    // -----------------------------------------------------------------------
+    // Network observation
+    // -----------------------------------------------------------------------
+    case "network": {
+      const subCommand = request.networkCommand ?? "requests";
+      switch (subCommand) {
+        case "requests": {
+          const queryResult = tab.getNetworkRequests({
+            since: request.since,
+            filter: request.filter,
+            method: request.method,
+            status: request.status,
+            limit: request.limit
+          });
+          const items = queryResult.items;
+          if (request.withBody) {
+            await Promise.all(
+              items.map(async (item) => {
+                if (item.failed || item.responseBody !== void 0 || item.bodyError !== void 0) return;
+                try {
+                  const body = await cdp.sessionCommand(
+                    target.id,
+                    "Network.getResponseBody",
+                    { requestId: item.requestId }
+                  );
+                  item.responseBody = body.body;
+                  item.responseBodyBase64 = body.base64Encoded;
+                } catch (error) {
+                  item.bodyError = error instanceof Error ? error.message : String(error);
+                }
+              })
+            );
+          }
+          return ok(request.id, {
+            networkRequests: items,
+            tab: shortId,
+            cursor: queryResult.cursor
+          });
+        }
+        case "route":
+          return ok(request.id, { routeCount: 0, tab: shortId });
+        case "unroute":
+          return ok(request.id, { routeCount: 0, tab: shortId });
+        case "clear":
+          tab.clearNetwork();
+          return ok(request.id, { tab: shortId });
+        default:
+          return fail(request.id, `Unknown network subcommand: ${subCommand}`);
+      }
+    }
+    // -----------------------------------------------------------------------
+    // Console observation
+    // -----------------------------------------------------------------------
+    case "console": {
+      const subCommand = request.consoleCommand ?? "get";
+      switch (subCommand) {
+        case "get": {
+          const queryResult = tab.getConsoleMessages({
+            since: request.since,
+            filter: request.filter,
+            limit: request.limit
+          });
+          return ok(request.id, {
+            consoleMessages: queryResult.items,
+            tab: shortId,
+            cursor: queryResult.cursor
+          });
+        }
+        case "clear":
+          tab.clearConsole();
+          return ok(request.id, { tab: shortId });
+        default:
+          return fail(request.id, `Unknown console subcommand: ${subCommand}`);
+      }
+    }
+    // -----------------------------------------------------------------------
+    // JS Errors observation
+    // -----------------------------------------------------------------------
+    case "errors": {
+      const subCommand = request.errorsCommand ?? "get";
+      switch (subCommand) {
+        case "get": {
+          const queryResult = tab.getJSErrors({
+            since: request.since,
+            filter: request.filter,
+            limit: request.limit
+          });
+          return ok(request.id, {
+            jsErrors: queryResult.items,
+            tab: shortId,
+            cursor: queryResult.cursor
+          });
+        }
+        case "clear":
+          tab.clearErrors();
+          return ok(request.id, { tab: shortId });
+        default:
+          return fail(request.id, `Unknown errors subcommand: ${subCommand}`);
+      }
+    }
+    // -----------------------------------------------------------------------
+    // Trace
+    // -----------------------------------------------------------------------
+    case "trace": {
+      const subCommand = request.traceCommand ?? "status";
+      switch (subCommand) {
+        case "start":
+          traceRecording = true;
+          traceEvents.length = 0;
+          return ok(request.id, {
+            traceStatus: { recording: true, eventCount: 0 },
+            tab: shortId
+          });
+        case "stop": {
+          traceRecording = false;
+          return ok(request.id, {
+            traceEvents: [...traceEvents],
+            traceStatus: { recording: false, eventCount: traceEvents.length },
+            tab: shortId
+          });
+        }
+        case "status":
+          return ok(request.id, {
+            traceStatus: { recording: traceRecording, eventCount: traceEvents.length },
+            tab: shortId
+          });
+        default:
+          return fail(request.id, `Unknown trace subcommand: ${subCommand}`);
+      }
+    }
+    // -----------------------------------------------------------------------
+    // History (not implemented in daemon yet)
+    // -----------------------------------------------------------------------
+    case "history": {
+      return fail(request.id, "History command is not supported in daemon mode");
+    }
+    default:
+      return fail(request.id, `Unknown action: ${request.action}`);
+  }
+}
+
+// packages/daemon/src/http-server.ts
+var HttpServer = class {
+  server = null;
+  host;
+  port;
+  token;
+  cdp;
+  onShutdown;
+  startTime = 0;
+  constructor(options) {
+    this.host = options.host ?? "127.0.0.1";
+    this.port = options.port ?? DAEMON_PORT;
+    this.token = options.token ?? null;
+    this.cdp = options.cdp;
+    this.onShutdown = options.onShutdown;
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  async start() {
+    return new Promise((resolve, reject) => {
+      this.server = createServer((req, res) => {
+        this.handleRequest(req, res);
+      });
+      this.server.on("error", reject);
+      this.server.listen(this.port, this.host, () => {
+        this.startTime = Date.now();
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server.close(() => resolve());
+      });
+    }
+  }
+  get uptime() {
+    if (this.startTime === 0) return 0;
+    return Math.floor((Date.now() - this.startTime) / 1e3);
+  }
+  // ---------------------------------------------------------------------------
+  // Auth
+  // ---------------------------------------------------------------------------
+  checkAuth(req, res) {
+    if (!this.token) return true;
+    const auth = req.headers.authorization ?? "";
+    if (auth === `Bearer ${this.token}`) return true;
+    this.sendJson(res, 401, { error: "Unauthorized" });
+    return false;
+  }
+  // ---------------------------------------------------------------------------
+  // Routing
+  // ---------------------------------------------------------------------------
+  handleRequest(req, res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (!this.checkAuth(req, res)) return;
+    const url = req.url ?? "/";
+    if (req.method === "POST" && url === "/command") {
+      this.handleCommand(req, res);
+    } else if (req.method === "POST" && url === "/api/fetch") {
+      this.handleApiFetch(req, res);
+    } else if (req.method === "GET" && url.startsWith("/api/capture")) {
+      this.handleApiCapture(req, res);
+    } else if (req.method === "GET" && url.startsWith("/api/storage")) {
+      this.handleApiStorage(req, res);
+    } else if (req.method === "GET" && url === "/status") {
+      this.handleStatus(req, res);
+    } else if (req.method === "POST" && url === "/shutdown") {
+      this.handleShutdown(req, res);
+    } else {
+      this.sendJson(res, 404, { error: "Not found" });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // POST /command
+  // ---------------------------------------------------------------------------
+  async handleCommand(req, res) {
+    try {
+      const body = await this.readBody(req);
+      const request = JSON.parse(body);
+      if (!this.cdp.connected) {
+        try {
+          await Promise.race([
+            this.cdp.waitUntilReady(),
+            new Promise(
+              (_, reject) => setTimeout(() => reject(new Error("CDP connection timeout")), COMMAND_TIMEOUT)
+            )
+          ]);
+        } catch {
+          const cdpTarget = `${this.cdp.host}:${this.cdp.port}`;
+          const reason = this.cdp.lastError || "unknown";
+          this.sendJson(res, 503, {
+            id: request.id,
+            success: false,
+            error: `Chrome not connected (CDP at ${cdpTarget})`,
+            reason,
+            hint: "Make sure Chrome is running. Try: bb-browser daemon shutdown && bb-browser tab list"
+          });
+          return;
+        }
+      }
+      const timeout = new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Command timeout")), COMMAND_TIMEOUT)
+      );
+      const response = await Promise.race([
+        dispatchRequest(this.cdp, request),
+        timeout
+      ]);
+      this.sendJson(res, 200, response);
+    } catch (error) {
+      this.sendJson(res, 400, {
+        success: false,
+        error: error instanceof Error ? error.message : "Invalid request"
+      });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // POST /api/fetch
+  // ---------------------------------------------------------------------------
+  /**
+   * 封装的 fetch API 路由
+   * 
+   * 请求体格式：
+   * {
+   *   "url": "https://example.com/api/data",
+   *   "method": "GET",  // 可选，默认 GET
+   *   "body": "...",    // 可选
+   *   "headers": {},    // 可选
+   *   "tabId": "..."    // 可选，指定 tab ID（支持短 ID）
+   * }
+   * 
+   * 响应格式：
+   * {
+   *   "status": 200,
+   *   "contentType": "application/json",
+   *   "body": {...}
+   * }
+   */
+  async handleApiFetch(req, res) {
+    try {
+      const body = await this.readBody(req);
+      const params = JSON.parse(body);
+      if (!params.url) {
+        this.sendJson(res, 400, {
+          error: "Missing url parameter",
+          hint: "\u8BF7\u6C42\u4F53\u5FC5\u987B\u5305\u542B url \u5B57\u6BB5"
+        });
+        return;
+      }
+      if (!this.cdp.connected) {
+        try {
+          await Promise.race([
+            this.cdp.waitUntilReady(),
+            new Promise(
+              (_, reject) => setTimeout(() => reject(new Error("CDP connection timeout")), COMMAND_TIMEOUT)
+            )
+          ]);
+        } catch {
+          const cdpTarget = `${this.cdp.host}:${this.cdp.port}`;
+          const reason = this.cdp.lastError || "unknown";
+          this.sendJson(res, 503, {
+            error: `Chrome not connected (CDP at ${cdpTarget})`,
+            reason,
+            hint: "Make sure Chrome is running. Try: bb-browser daemon shutdown && bb-browser tab list"
+          });
+          return;
+        }
+      }
+      let targetTabId = params.tabId;
+      if (!targetTabId && params.url) {
+        try {
+          const targetUrl = new URL(params.url);
+          const targetOrigin = targetUrl.origin;
+          const targets = (await this.cdp.getTargets()).filter((t) => t.type === "page");
+          const sameOriginTab = targets.find((t) => {
+            try {
+              const tabUrl = new URL(t.url);
+              return tabUrl.origin === targetOrigin;
+            } catch {
+              return false;
+            }
+          });
+          if (sameOriginTab) {
+            const tabState = this.cdp.tabManager.getTab(sameOriginTab.id);
+            targetTabId = tabState?.shortId || sameOriginTab.id;
+          } else {
+            const newTabResp = await this.cdp.browserCommand(
+              "Target.createTarget",
+              { url: targetOrigin, background: true }
+            );
+            await this.cdp.attachAndEnable(newTabResp.targetId);
+            const newTab = this.cdp.tabManager.getTab(newTabResp.targetId);
+            targetTabId = newTab?.shortId || newTabResp.targetId;
+            await new Promise((resolve) => setTimeout(resolve, 1e3));
+          }
+        } catch (e) {
+        }
+      }
+      const request = {
+        id: `fetch-${Date.now()}`,
+        action: "fetch",
+        url: params.url,
+        method: params.method,
+        body: params.body,
+        headers: params.headers,
+        credentials: params.credentials,
+        tabId: targetTabId
+      };
+      const timeout = new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Fetch timeout")), COMMAND_TIMEOUT)
+      );
+      const response = await Promise.race([
+        dispatchRequest(this.cdp, request),
+        timeout
+      ]);
+      if (!response.success) {
+        this.sendJson(res, 500, {
+          error: response.error,
+          hint: "Fetch \u6267\u884C\u5931\u8D25"
+        });
+        return;
+      }
+      this.sendJson(res, 200, response.data?.fetchResponse ?? {
+        error: "No fetch response data"
+      });
+    } catch (error) {
+      this.sendJson(res, 400, {
+        error: error instanceof Error ? error.message : "Invalid request",
+        hint: "\u8BF7\u6C42\u683C\u5F0F\u9519\u8BEF\u6216\u6267\u884C\u5931\u8D25"
+      });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // GET /api/capture
+  // ---------------------------------------------------------------------------
+  /**
+   * 抓包接口
+   * 
+   * 请求格式：
+   * GET /api/capture?url=https://example.com&pattern=api\\.&timeout=5000
+   * 
+   * 参数说明：
+   * - url: 要访问的页面 URL（必填）
+   * - pattern: URL 匹配正则（可选）
+   * - timeout: 等待时间（毫秒，可选，默认 5000）
+   * 
+   * 响应格式：
+   * {
+   *   "url": "...",
+   *   "pattern": "...",
+   *   "totalRequests": 50,
+   *   "matchedRequests": 3,
+   *   "requests": [...]
+   * }
+   */
+  async handleApiCapture(req, res) {
+    try {
+      const urlObj = new URL(req.url || "", `http://${req.headers.host}`);
+      const targetUrl = urlObj.searchParams.get("url");
+      const pattern = urlObj.searchParams.get("pattern") || void 0;
+      const timeout = parseInt(urlObj.searchParams.get("timeout") || "5000", 10);
+      if (!targetUrl) {
+        this.sendJson(res, 400, {
+          error: "Missing url parameter",
+          hint: "\u8BF7\u6C42\u5FC5\u987B\u5305\u542B url \u53C2\u6570\uFF0C\u4F8B\u5982: /api/capture?url=https://example.com"
+        });
+        return;
+      }
+      if (!this.cdp.connected) {
+        try {
+          await Promise.race([
+            this.cdp.waitUntilReady(),
+            new Promise(
+              (_, reject) => setTimeout(() => reject(new Error("CDP connection timeout")), COMMAND_TIMEOUT)
+            )
+          ]);
+        } catch {
+          const cdpTarget = `${this.cdp.host}:${this.cdp.port}`;
+          const reason = this.cdp.lastError || "unknown";
+          this.sendJson(res, 503, {
+            error: `Chrome not connected (CDP at ${cdpTarget})`,
+            reason,
+            hint: "Make sure Chrome is running."
+          });
+          return;
+        }
+      }
+      const created = await this.cdp.browserCommand(
+        "Target.createTarget",
+        { url: "about:blank", background: true }
+      );
+      await this.cdp.attachAndEnable(created.targetId);
+      const tab = this.cdp.tabManager.getTab(created.targetId);
+      if (!tab) {
+        this.sendJson(res, 500, {
+          error: "Failed to create tab",
+          hint: "\u65E0\u6CD5\u521B\u5EFA\u65B0\u6807\u7B7E\u9875"
+        });
+        return;
+      }
+      try {
+        tab.clearNetwork();
+        await this.cdp.pageCommand(created.targetId, "Page.navigate", { url: targetUrl });
+        const waitTime = timeout;
+        await new Promise((resolve) => setTimeout(resolve, waitTime));
+        const allRequests = tab.getNetworkRequests({}).items;
+        let filteredRequests = allRequests;
+        if (pattern) {
+          try {
+            const regex = new RegExp(pattern);
+            filteredRequests = allRequests.filter((req2) => regex.test(req2.url));
+          } catch (e) {
+            filteredRequests = allRequests.filter((req2) => req2.url.includes(pattern));
+          }
+        }
+        await Promise.all(
+          filteredRequests.map(async (item) => {
+            if (item.failed || item.responseBody !== void 0 || item.bodyError !== void 0) return;
+            try {
+              const bodyResult = await this.cdp.sessionCommand(
+                created.targetId,
+                "Network.getResponseBody",
+                { requestId: item.requestId }
+              );
+              item.responseBody = bodyResult.body;
+              item.responseBodyBase64 = bodyResult.base64Encoded;
+            } catch (error) {
+              item.bodyError = error instanceof Error ? error.message : String(error);
+            }
+          })
+        );
+        this.sendJson(res, 200, {
+          url: targetUrl,
+          pattern,
+          totalRequests: allRequests.length,
+          matchedRequests: filteredRequests.length,
+          requests: filteredRequests
+        });
+      } finally {
+        await this.cdp.browserCommand("Target.closeTarget", { targetId: created.targetId }).catch(() => {
+        });
+      }
+    } catch (error) {
+      this.sendJson(res, 400, {
+        error: error instanceof Error ? error.message : "Invalid request",
+        hint: "\u8BF7\u6C42\u683C\u5F0F\u9519\u8BEF\u6216\u6267\u884C\u5931\u8D25"
+      });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // GET /api/storage
+  // ---------------------------------------------------------------------------
+  /**
+   * 存储接口
+   * 
+   * 请求格式：
+   * GET /api/storage?domain=https://example.com
+   * 
+   * 参数说明：
+   * - domain: 目标域名（必填，必须包含协议）
+   * 
+   * 响应格式：
+   * {
+   *   "domain": "https://example.com",
+   *   "cookies": [...],
+   *   "localStorage": {...},
+   *   "sessionStorage": {...}
+   * }
+   */
+  async handleApiStorage(req, res) {
+    try {
+      const urlObj = new URL(req.url || "", `http://${req.headers.host}`);
+      const domain = urlObj.searchParams.get("domain");
+      if (!domain) {
+        this.sendJson(res, 400, {
+          error: "Missing domain parameter",
+          hint: "\u8BF7\u6C42\u5FC5\u987B\u5305\u542B domain \u53C2\u6570\uFF0C\u4F8B\u5982: /api/storage?domain=https://example.com"
+        });
+        return;
+      }
+      if (!this.cdp.connected) {
+        try {
+          await Promise.race([
+            this.cdp.waitUntilReady(),
+            new Promise(
+              (_, reject) => setTimeout(() => reject(new Error("CDP connection timeout")), COMMAND_TIMEOUT)
+            )
+          ]);
+        } catch {
+          const cdpTarget = `${this.cdp.host}:${this.cdp.port}`;
+          const reason = this.cdp.lastError || "unknown";
+          this.sendJson(res, 503, {
+            error: `Chrome not connected (CDP at ${cdpTarget})`,
+            reason,
+            hint: "Make sure Chrome is running."
+          });
+          return;
+        }
+      }
+      let targetId;
+      const targets = (await this.cdp.getTargets()).filter((t) => t.type === "page");
+      const sameOriginTab = targets.find((t) => {
+        try {
+          const tabUrl = new URL(t.url);
+          const targetUrl = new URL(domain);
+          return tabUrl.origin === targetUrl.origin;
+        } catch {
+          return false;
+        }
+      });
+      if (sameOriginTab) {
+        targetId = sameOriginTab.id;
+      } else {
+        const created = await this.cdp.browserCommand(
+          "Target.createTarget",
+          { url: domain, background: true }
+        );
+        await this.cdp.attachAndEnable(created.targetId);
+        targetId = created.targetId;
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+      }
+      const cookiesResult = await this.cdp.sessionCommand(targetId, "Network.getCookies", {});
+      const storageScript = `(() => {
+        const local = {};
+        const session = {};
+        try {
+          for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key) local[key] = localStorage.getItem(key);
+          }
+        } catch (e) {}
+        try {
+          for (let i = 0; i < sessionStorage.length; i++) {
+            const key = sessionStorage.key(i);
+            if (key) session[key] = sessionStorage.getItem(key);
+          }
+        } catch (e) {}
+        return { localStorage: local, sessionStorage: session };
+      })()`;
+      const storageResult = await this.cdp.evaluate(targetId, storageScript, true);
+      this.sendJson(res, 200, {
+        domain,
+        cookies: cookiesResult.cookies,
+        localStorage: storageResult?.localStorage ?? {},
+        sessionStorage: storageResult?.sessionStorage ?? {}
+      });
+    } catch (error) {
+      this.sendJson(res, 400, {
+        error: error instanceof Error ? error.message : "Invalid request",
+        hint: "\u8BF7\u6C42\u683C\u5F0F\u9519\u8BEF\u6216\u6267\u884C\u5931\u8D25"
+      });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // GET /status
+  // ---------------------------------------------------------------------------
+  handleStatus(_req, res) {
+    const tabs = this.cdp.tabManager.allTabs().map((tab) => ({
+      shortId: tab.shortId,
+      targetId: tab.targetId,
+      networkRequests: tab.networkRequests.size,
+      consoleMessages: tab.consoleMessages.size,
+      jsErrors: tab.jsErrors.size,
+      lastActionSeq: tab.lastActionSeq
+    }));
+    this.sendJson(res, 200, {
+      running: true,
+      cdpConnected: this.cdp.connected,
+      uptime: this.uptime,
+      currentSeq: this.cdp.tabManager.currentSeq(),
+      currentTargetId: this.cdp.currentTargetId,
+      tabs
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // POST /shutdown
+  // ---------------------------------------------------------------------------
+  handleShutdown(_req, res) {
+    this.sendJson(res, 200, { code: 0, message: "Shutting down" });
+    setTimeout(() => {
+      if (this.onShutdown) {
+        this.onShutdown();
+      }
+    }, 100);
+  }
+  // ---------------------------------------------------------------------------
+  // Utility
+  // ---------------------------------------------------------------------------
+  readBody(req) {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+      req.on("error", reject);
+    });
+  }
+  sendJson(res, status, data) {
+    const body = JSON.stringify(data);
+    res.writeHead(status, {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(body)
+    });
+    res.end(body);
+  }
+};
+
+// packages/daemon/src/cdp-connection.ts
+import { request as httpRequest } from "http";
+import WebSocket from "ws";
+function fetchJson(url) {
+  return new Promise((resolve, reject) => {
+    const req = httpRequest(url, { method: "GET" }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+      res.on("end", () => {
+        const raw = Buffer.concat(chunks).toString("utf8");
+        if ((res.statusCode ?? 500) >= 400) {
+          reject(new Error(`HTTP ${res.statusCode ?? 500}: ${raw}`));
+          return;
+        }
+        try {
+          resolve(JSON.parse(raw));
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+function connectWebSocket(url) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    ws.once("open", () => resolve(ws));
+    ws.once("error", reject);
+  });
+}
+function normalizeHeaders(headers) {
+  if (!headers || typeof headers !== "object") return void 0;
+  return Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [key, String(value)])
+  );
+}
+var CdpConnection = class {
+  socket = null;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  /** targetId -> sessionId (flat-mode) */
+  sessions = /* @__PURE__ */ new Map();
+  /** sessionId -> targetId */
+  attachedTargets = /* @__PURE__ */ new Map();
+  host;
+  port;
+  tabManager;
+  /** Current (most recently selected) target ID. */
+  currentTargetId;
+  connectionPromise = null;
+  _connected = false;
+  /** Last connection error (for diagnostics in 503 responses). */
+  lastError = null;
+  /** Resolvers for commands queued before CDP is ready. */
+  readyWaiters = [];
+  constructor(host, port, tabManager) {
+    this.host = host;
+    this.port = port;
+    this.tabManager = tabManager;
+  }
+  get connected() {
+    return this._connected && this.socket !== null && this.socket.readyState === WebSocket.OPEN;
+  }
+  // ---------------------------------------------------------------------------
+  // Connection lifecycle
+  // ---------------------------------------------------------------------------
+  /**
+   * Connect to Chrome's browser-level WebSocket endpoint.
+   * Idempotent — returns immediately if already connected.
+   */
+  async connect() {
+    if (this._connected) return;
+    if (this.connectionPromise) return this.connectionPromise;
+    this.connectionPromise = this.doConnect();
+    try {
+      await this.connectionPromise;
+      this.lastError = null;
+    } catch (err) {
+      this.lastError = err instanceof Error ? err.message : String(err);
+      const connErr = new Error(this.lastError);
+      for (const waiter of this.readyWaiters) {
+        waiter.reject(connErr);
+      }
+      this.readyWaiters = [];
+      throw err;
+    } finally {
+      this.connectionPromise = null;
+    }
+  }
+  async doConnect() {
+    const versionData = await fetchJson(
+      `http://${this.host}:${this.port}/json/version`
+    );
+    const wsUrl = versionData.webSocketDebuggerUrl;
+    if (typeof wsUrl !== "string" || !wsUrl) {
+      throw new Error("CDP endpoint missing webSocketDebuggerUrl");
+    }
+    const ws = await connectWebSocket(wsUrl);
+    this.socket = ws;
+    this._connected = true;
+    this.setupListeners(ws);
+    await this.browserCommand("Target.setDiscoverTargets", { discover: true });
+    const result = await this.browserCommand("Target.getTargets");
+    const pages = (result.targetInfos || []).filter((t) => t.type === "page");
+    for (const page of pages) {
+      await this.attachAndEnable(page.targetId).catch(() => {
+      });
+    }
+    for (const waiter of this.readyWaiters) {
+      waiter.resolve();
+    }
+    this.readyWaiters = [];
+  }
+  /** Wait until CDP connection is established (for two-phase startup). */
+  waitUntilReady() {
+    if (this._connected) return Promise.resolve();
+    if (this.lastError) return Promise.reject(new Error(this.lastError));
+    return new Promise((resolve, reject) => {
+      this.readyWaiters.push({ resolve, reject });
+    });
+  }
+  /** Gracefully close the CDP connection. */
+  disconnect() {
+    if (this.socket) {
+      try {
+        this.socket.close();
+      } catch {
+      }
+    }
+    this.socket = null;
+    this._connected = false;
+    for (const p of this.pending.values()) {
+      p.reject(new Error("CDP connection closed"));
+    }
+    this.pending.clear();
+    for (const waiter of this.readyWaiters) {
+      waiter.reject(new Error("CDP connection closed before ready"));
+    }
+    this.readyWaiters = [];
+  }
+  // ---------------------------------------------------------------------------
+  // WebSocket message handling
+  // ---------------------------------------------------------------------------
+  setupListeners(ws) {
+    ws.on("message", (raw) => {
+      const message = JSON.parse(raw.toString());
+      if (typeof message.id === "number") {
+        const p = this.pending.get(message.id);
+        if (!p) return;
+        this.pending.delete(message.id);
+        if (message.error) {
+          p.reject(
+            new Error(
+              `${p.method}: ${message.error.message ?? "Unknown CDP error"}`
+            )
+          );
+        } else {
+          p.resolve(message.result);
+        }
+        return;
+      }
+      if (message.method === "Target.attachedToTarget") {
+        const params = message.params;
+        const sessionId = params.sessionId;
+        const targetInfo = params.targetInfo;
+        if (typeof sessionId === "string" && typeof targetInfo?.targetId === "string") {
+          this.sessions.set(targetInfo.targetId, sessionId);
+          this.attachedTargets.set(sessionId, targetInfo.targetId);
+        }
+        return;
+      }
+      if (message.method === "Target.detachedFromTarget") {
+        const params = message.params;
+        const sessionId = params.sessionId;
+        if (typeof sessionId === "string") {
+          const targetId = this.attachedTargets.get(sessionId);
+          if (targetId) {
+            this.sessions.delete(targetId);
+            this.attachedTargets.delete(sessionId);
+            this.tabManager.removeTab(targetId);
+            if (this.currentTargetId === targetId) {
+              this.currentTargetId = void 0;
+            }
+          }
+        }
+        return;
+      }
+      if (message.method === "Target.targetCreated") {
+        const params = message.params;
+        const targetInfo = params.targetInfo;
+        if (targetInfo?.type === "page" && typeof targetInfo.targetId === "string") {
+          this.attachAndEnable(targetInfo.targetId).catch(() => {
+          });
+        }
+        return;
+      }
+      if (message.method === "Target.targetDestroyed") {
+        const params = message.params;
+        const targetId = params.targetId;
+        if (typeof targetId === "string") {
+          const sessionId = this.sessions.get(targetId);
+          if (sessionId) {
+            this.sessions.delete(targetId);
+            this.attachedTargets.delete(sessionId);
+          }
+          this.tabManager.removeTab(targetId);
+          if (this.currentTargetId === targetId) {
+            this.currentTargetId = void 0;
+          }
+        }
+        return;
+      }
+      if (typeof message.sessionId === "string" && typeof message.method === "string") {
+        const targetId = this.attachedTargets.get(message.sessionId);
+        if (targetId) {
+          this.handleSessionEvent(targetId, message).catch(() => {
+          });
+        }
+      }
+    });
+    ws.on("close", () => {
+      this._connected = false;
+      this.socket = null;
+      this.lastError = "CDP WebSocket closed unexpectedly";
+      for (const p of this.pending.values()) {
+        p.reject(new Error("CDP connection closed"));
+      }
+      this.pending.clear();
+      const closeErr = new Error(this.lastError);
+      for (const waiter of this.readyWaiters) {
+        waiter.reject(closeErr);
+      }
+      this.readyWaiters = [];
+    });
+    ws.on("error", () => {
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Session event routing (network, console, errors, dialog)
+  // ---------------------------------------------------------------------------
+  async handleSessionEvent(targetId, event) {
+    const method = event.method;
+    const params = event.params ?? {};
+    if (typeof method !== "string") return;
+    const tab = this.tabManager.getTab(targetId);
+    if (!tab) return;
+    if (method === "Page.javascriptDialogOpening") {
+      if (tab.dialogHandler) {
+        await this.sessionCommand(targetId, "Page.handleJavaScriptDialog", {
+          accept: tab.dialogHandler.accept,
+          ...tab.dialogHandler.promptText !== void 0 ? { promptText: tab.dialogHandler.promptText } : {}
+        });
+      }
+      return;
+    }
+    if (method === "Network.requestWillBeSent") {
+      const requestId = typeof params.requestId === "string" ? params.requestId : void 0;
+      const request = params.request;
+      if (!requestId || !request) return;
+      tab.addNetworkRequest(requestId, {
+        url: String(request.url ?? ""),
+        method: String(request.method ?? "GET"),
+        type: String(params.type ?? "Other"),
+        timestamp: Math.round(Number(params.timestamp ?? Date.now()) * 1e3),
+        requestHeaders: normalizeHeaders(request.headers),
+        requestBody: typeof request.postData === "string" ? request.postData : void 0
+      });
+      return;
+    }
+    if (method === "Network.responseReceived") {
+      const requestId = typeof params.requestId === "string" ? params.requestId : void 0;
+      const response = params.response;
+      if (!requestId || !response) return;
+      tab.updateNetworkResponse(requestId, {
+        status: typeof response.status === "number" ? response.status : void 0,
+        statusText: typeof response.statusText === "string" ? response.statusText : void 0,
+        responseHeaders: normalizeHeaders(response.headers),
+        mimeType: typeof response.mimeType === "string" ? response.mimeType : void 0
+      });
+      return;
+    }
+    if (method === "Network.loadingFailed") {
+      const requestId = typeof params.requestId === "string" ? params.requestId : void 0;
+      if (!requestId) return;
+      tab.updateNetworkFailure(
+        requestId,
+        typeof params.errorText === "string" ? params.errorText : "Unknown error"
+      );
+      return;
+    }
+    if (method === "Runtime.consoleAPICalled") {
+      const type = String(params.type ?? "log");
+      const args = Array.isArray(params.args) ? params.args : [];
+      const text = args.map((arg) => {
+        if (typeof arg.value === "string") return arg.value;
+        if (arg.value !== void 0) return String(arg.value);
+        if (typeof arg.description === "string") return arg.description;
+        return "";
+      }).filter(Boolean).join(" ");
+      const stack = params.stackTrace;
+      const firstCallFrame = Array.isArray(stack?.callFrames) ? stack?.callFrames[0] : void 0;
+      const consoleTypeMap = { warning: "warn" };
+      const normalizedType = consoleTypeMap[type] || type;
+      tab.addConsoleMessage({
+        type: ["log", "info", "warn", "error", "debug"].includes(normalizedType) ? normalizedType : "log",
+        text,
+        timestamp: Math.round(Number(params.timestamp ?? Date.now())),
+        url: typeof firstCallFrame?.url === "string" ? firstCallFrame.url : void 0,
+        lineNumber: typeof firstCallFrame?.lineNumber === "number" ? firstCallFrame.lineNumber : void 0
+      });
+      return;
+    }
+    if (method === "Runtime.exceptionThrown") {
+      const details = params.exceptionDetails;
+      if (!details) return;
+      const exception = details.exception;
+      const stackTrace = details.stackTrace;
+      const callFrames = Array.isArray(stackTrace?.callFrames) ? stackTrace.callFrames : [];
+      tab.addJSError({
+        message: typeof exception?.description === "string" ? exception.description : String(details.text ?? "JavaScript exception"),
+        url: typeof details.url === "string" ? details.url : typeof callFrames[0]?.url === "string" ? String(callFrames[0].url) : void 0,
+        lineNumber: typeof details.lineNumber === "number" ? details.lineNumber : void 0,
+        columnNumber: typeof details.columnNumber === "number" ? details.columnNumber : void 0,
+        stackTrace: callFrames.length > 0 ? callFrames.map(
+          (frame) => `${String(frame.functionName ?? "<anonymous>")} (${String(frame.url ?? "")}:${String(frame.lineNumber ?? 0)}:${String(frame.columnNumber ?? 0)})`
+        ).join("\n") : void 0,
+        timestamp: Date.now()
+      });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Target management
+  // ---------------------------------------------------------------------------
+  /** Attach to a target and enable required CDP domains. */
+  async attachAndEnable(targetId) {
+    if (this.sessions.has(targetId)) {
+      this.tabManager.addTab(targetId);
+      return this.sessions.get(targetId);
+    }
+    const result = await this.browserCommand(
+      "Target.attachToTarget",
+      { targetId, flatten: true }
+    );
+    this.sessions.set(targetId, result.sessionId);
+    this.attachedTargets.set(result.sessionId, targetId);
+    this.tabManager.addTab(targetId);
+    await this.sessionCommand(targetId, "Page.enable").catch(() => {
+    });
+    await this.sessionCommand(targetId, "Runtime.enable").catch(() => {
+    });
+    await this.sessionCommand(targetId, "Network.enable").catch(() => {
+    });
+    await this.sessionCommand(targetId, "DOM.enable").catch(() => {
+    });
+    await this.sessionCommand(targetId, "Accessibility.enable").catch(() => {
+    });
+    return result.sessionId;
+  }
+  /** Get all targets via CDP Target.getTargets. */
+  async getTargets() {
+    const result = await this.browserCommand("Target.getTargets");
+    return (result.targetInfos || []).map((t) => ({
+      id: t.targetId,
+      type: t.type,
+      title: t.title,
+      url: t.url
+    }));
+  }
+  /**
+   * Ensure we have a valid page target and return it. Supports resolution by:
+   *   - short ID string
+   *   - full target ID string
+   *   - numeric index
+   *   - undefined (use currentTargetId or first page)
+   */
+  async ensurePageTarget(tabRef) {
+    const targets = (await this.getTargets()).filter((t) => t.type === "page");
+    if (targets.length === 0) throw new Error("No page target found");
+    let target;
+    if (typeof tabRef === "string") {
+      const resolvedTargetId = this.tabManager.resolveShortId(tabRef);
+      if (resolvedTargetId) {
+        target = targets.find((t) => t.id === resolvedTargetId);
+      }
+      if (!target) {
+        target = targets.find((t) => t.id === tabRef);
+      }
+      if (!target) {
+        const num = Number(tabRef);
+        if (!Number.isNaN(num)) {
+          target = targets[num];
+        }
+      }
+    } else if (typeof tabRef === "number") {
+      target = targets[tabRef];
+    } else if (this.currentTargetId) {
+      target = targets.find((t) => t.id === this.currentTargetId);
+    }
+    if (typeof tabRef === "string" && !target) {
+      throw new Error(`Tab not found: ${tabRef}`);
+    }
+    if (!target) {
+      target = targets.find((t) => t.url && !t.url.startsWith("about:") && !t.url.startsWith("chrome:"));
+    }
+    target ??= targets[0];
+    this.currentTargetId = target.id;
+    await this.attachAndEnable(target.id);
+    return target;
+  }
+  /** Check if a session exists for a given targetId. */
+  hasSession(targetId) {
+    return this.sessions.has(targetId);
+  }
+  // ---------------------------------------------------------------------------
+  // CDP command sending
+  // ---------------------------------------------------------------------------
+  /** Send a browser-level CDP command. */
+  async browserCommand(method, params = {}) {
+    if (!this.socket) throw new Error("CDP not connected");
+    const id = this.nextId++;
+    const payload = JSON.stringify({ id, method, params });
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, {
+        resolve,
+        reject,
+        method
+      });
+      this.socket.send(payload);
+    });
+  }
+  /** Send a session-level CDP command (flat protocol). */
+  async sessionCommand(targetId, method, params = {}) {
+    if (!this.socket) throw new Error("CDP not connected");
+    const sessionId = this.sessions.get(targetId) ?? await this.attachAndEnable(targetId);
+    const id = this.nextId++;
+    const payload = JSON.stringify({ id, method, params, sessionId });
+    return new Promise((resolve, reject) => {
+      const check = (raw) => {
+        const msg = JSON.parse(raw.toString());
+        if (msg.id === id && msg.sessionId === sessionId) {
+          this.socket.off("message", check);
+          if (msg.error) {
+            reject(
+              new Error(
+                `${method}: ${msg.error.message ?? "Unknown CDP error"}`
+              )
+            );
+          } else {
+            resolve(msg.result);
+          }
+        }
+      };
+      this.socket.on("message", check);
+      this.socket.send(payload);
+    });
+  }
+  /**
+   * Send a page-scoped command. If the tab has an active iframe,
+   * the frameId is injected into the params.
+   */
+  async pageCommand(targetId, method, params = {}) {
+    const tab = this.tabManager.getTab(targetId);
+    const frameId = tab?.activeFrameId;
+    return this.sessionCommand(
+      targetId,
+      method,
+      frameId ? { ...params, frameId } : params
+    );
+  }
+  /**
+   * Evaluate JavaScript expression on a target.
+   */
+  async evaluate(targetId, expression, returnByValue = true) {
+    const result = await this.sessionCommand(targetId, "Runtime.evaluate", {
+      expression,
+      awaitPromise: true,
+      returnByValue
+    });
+    if (result.exceptionDetails) {
+      throw new Error(
+        result.exceptionDetails.exception?.description || result.exceptionDetails.text || "Runtime.evaluate failed"
+      );
+    }
+    return result.result.value ?? result.result;
+  }
+};
+
+// packages/daemon/src/ring-buffer.ts
+var RingBuffer = class {
+  items;
+  head = 0;
+  // next write position
+  count = 0;
+  capacity;
+  constructor(capacity) {
+    if (capacity < 1) throw new Error("RingBuffer capacity must be >= 1");
+    this.capacity = capacity;
+    this.items = new Array(capacity);
+  }
+  /** Number of elements currently stored. */
+  get size() {
+    return this.count;
+  }
+  /** Push a new element, evicting the oldest if at capacity. */
+  push(item) {
+    this.items[this.head] = item;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.count < this.capacity) {
+      this.count++;
+    }
+  }
+  /** Return all stored elements in insertion order (oldest first). */
+  toArray() {
+    if (this.count === 0) return [];
+    const result = new Array(this.count);
+    const start = this.count < this.capacity ? 0 : this.head;
+    for (let i = 0; i < this.count; i++) {
+      result[i] = this.items[(start + i) % this.capacity];
+    }
+    return result;
+  }
+  /** Remove all elements. */
+  clear() {
+    this.items.fill(void 0);
+    this.head = 0;
+    this.count = 0;
+  }
+};
+
+// packages/daemon/src/tab-state.ts
+var NETWORK_CAPACITY = 500;
+var CONSOLE_CAPACITY = 200;
+var ERRORS_CAPACITY = 100;
+var TabState = class {
+  constructor(targetId, shortId, nextSeq) {
+    this.nextSeq = nextSeq;
+    this.targetId = targetId;
+    this.shortId = shortId;
+  }
+  targetId;
+  shortId;
+  networkRequests = new RingBuffer(NETWORK_CAPACITY);
+  consoleMessages = new RingBuffer(CONSOLE_CAPACITY);
+  jsErrors = new RingBuffer(ERRORS_CAPACITY);
+  /** Lookup in-flight network requests by requestId for response/failure updates. */
+  networkByRequestId = /* @__PURE__ */ new Map();
+  /** seq of the last user-initiated action on this tab. */
+  lastActionSeq = 0;
+  /** Element refs from the most recent snapshot. */
+  refs = {};
+  /** Active frame ID for iframe navigation, null = main frame. */
+  activeFrameId = null;
+  /** Dialog auto-handler config. */
+  dialogHandler = null;
+  // --------------- Action seq ---------------
+  /** Increment global seq and record it as this tab's last action. */
+  recordAction() {
+    const seq = this.nextSeq();
+    this.lastActionSeq = seq;
+    return seq;
+  }
+  // --------------- Network events ---------------
+  addNetworkRequest(requestId, info) {
+    const seq = this.nextSeq();
+    const entry = { ...info, requestId, seq };
+    this.networkRequests.push(entry);
+    this.networkByRequestId.set(requestId, entry);
+  }
+  updateNetworkResponse(requestId, data) {
+    const existing = this.networkByRequestId.get(requestId);
+    if (!existing) return;
+    if (data.status !== void 0) existing.status = data.status;
+    if (data.statusText !== void 0) existing.statusText = data.statusText;
+    if (data.responseHeaders !== void 0) existing.responseHeaders = data.responseHeaders;
+    if (data.mimeType !== void 0) existing.mimeType = data.mimeType;
+  }
+  updateNetworkFailure(requestId, reason) {
+    const existing = this.networkByRequestId.get(requestId);
+    if (!existing) return;
+    existing.failed = true;
+    existing.failureReason = reason;
+  }
+  // --------------- Console events ---------------
+  addConsoleMessage(info) {
+    const seq = this.nextSeq();
+    this.consoleMessages.push({ ...info, seq });
+  }
+  // --------------- JS Error events ---------------
+  addJSError(info) {
+    const seq = this.nextSeq();
+    this.jsErrors.push({ ...info, seq });
+  }
+  // --------------- Query helpers ---------------
+  getNetworkRequests(options) {
+    let items = this.networkRequests.toArray();
+    if (options?.since !== void 0) {
+      const threshold = options.since === "last_action" ? this.lastActionSeq : options.since;
+      items = items.filter((item) => item.seq > threshold);
+    }
+    if (options?.filter) {
+      const f = options.filter;
+      items = items.filter((item) => item.url.includes(f));
+    }
+    if (options?.method) {
+      const m = options.method.toUpperCase();
+      items = items.filter((item) => item.method === m);
+    }
+    if (options?.status) {
+      const s = options.status;
+      if (s === "4xx") {
+        items = items.filter((item) => item.status !== void 0 && item.status >= 400 && item.status < 500);
+      } else if (s === "5xx") {
+        items = items.filter((item) => item.status !== void 0 && item.status >= 500 && item.status < 600);
+      } else {
+        const code = Number(s);
+        if (!Number.isNaN(code)) {
+          items = items.filter((item) => item.status === code);
+        }
+      }
+    }
+    if (options?.limit !== void 0 && options.limit > 0 && items.length > options.limit) {
+      items = items.slice(-options.limit);
+    }
+    const sinceThreshold = options?.since !== void 0 ? options.since === "last_action" ? this.lastActionSeq : options.since : 0;
+    const cursor = items.length > 0 ? Math.max(...items.map((i) => i.seq)) : sinceThreshold;
+    return { items, cursor };
+  }
+  getConsoleMessages(options) {
+    let items = this.consoleMessages.toArray();
+    if (options?.since !== void 0) {
+      const threshold = options.since === "last_action" ? this.lastActionSeq : options.since;
+      items = items.filter((item) => item.seq > threshold);
+    }
+    if (options?.filter) {
+      const f = options.filter;
+      items = items.filter((item) => item.text.includes(f));
+    }
+    if (options?.limit !== void 0 && options.limit > 0 && items.length > options.limit) {
+      items = items.slice(-options.limit);
+    }
+    const sinceThreshold = options?.since !== void 0 ? options.since === "last_action" ? this.lastActionSeq : options.since : 0;
+    const cursor = items.length > 0 ? Math.max(...items.map((i) => i.seq)) : sinceThreshold;
+    return { items, cursor };
+  }
+  getJSErrors(options) {
+    let items = this.jsErrors.toArray();
+    if (options?.since !== void 0) {
+      const threshold = options.since === "last_action" ? this.lastActionSeq : options.since;
+      items = items.filter((item) => item.seq > threshold);
+    }
+    if (options?.filter) {
+      const f = options.filter;
+      items = items.filter(
+        (item) => item.message.includes(f) || (item.url?.includes(f) ?? false)
+      );
+    }
+    if (options?.limit !== void 0 && options.limit > 0 && items.length > options.limit) {
+      items = items.slice(-options.limit);
+    }
+    const sinceThreshold = options?.since !== void 0 ? options.since === "last_action" ? this.lastActionSeq : options.since : 0;
+    const cursor = items.length > 0 ? Math.max(...items.map((i) => i.seq)) : sinceThreshold;
+    return { items, cursor };
+  }
+  // --------------- Clear helpers ---------------
+  clearNetwork() {
+    this.networkRequests.clear();
+    this.networkByRequestId.clear();
+  }
+  clearConsole() {
+    this.consoleMessages.clear();
+  }
+  clearErrors() {
+    this.jsErrors.clear();
+  }
+};
+var TabStateManager = class {
+  seq = 0;
+  tabs = /* @__PURE__ */ new Map();
+  // targetId -> TabState
+  shortToTarget = /* @__PURE__ */ new Map();
+  // shortId -> targetId
+  targetToShort = /* @__PURE__ */ new Map();
+  // targetId -> shortId
+  /** Generate a globally unique short ID for a target. */
+  generateShortId(targetId) {
+    for (let len = 4; len <= targetId.length; len++) {
+      const candidate = targetId.slice(-len).toLowerCase();
+      if (!this.shortToTarget.has(candidate)) {
+        return candidate;
+      }
+    }
+    return targetId.toLowerCase();
+  }
+  /** Get next seq (globally monotonic). */
+  nextSeq() {
+    return ++this.seq;
+  }
+  /** Get current seq without incrementing. */
+  currentSeq() {
+    return this.seq;
+  }
+  /** Register a new tab. Returns the TabState. */
+  addTab(targetId) {
+    const existing = this.tabs.get(targetId);
+    if (existing) return existing;
+    const shortId = this.generateShortId(targetId);
+    const tab = new TabState(targetId, shortId, () => this.nextSeq());
+    this.tabs.set(targetId, tab);
+    this.shortToTarget.set(shortId, targetId);
+    this.targetToShort.set(targetId, shortId);
+    return tab;
+  }
+  /** Remove a tab (on targetDestroyed / detach). */
+  removeTab(targetId) {
+    const tab = this.tabs.get(targetId);
+    if (!tab) return;
+    this.shortToTarget.delete(tab.shortId);
+    this.targetToShort.delete(targetId);
+    this.tabs.delete(targetId);
+  }
+  /** Get tab by targetId. */
+  getTab(targetId) {
+    return this.tabs.get(targetId);
+  }
+  /** Resolve a short ID to a targetId. */
+  resolveShortId(shortId) {
+    return this.shortToTarget.get(shortId);
+  }
+  /** Get the short ID for a targetId. */
+  getShortId(targetId) {
+    return this.targetToShort.get(targetId);
+  }
+  /** Get all active tabs. */
+  allTabs() {
+    return Array.from(this.tabs.values());
+  }
+  /** Get tab count. */
+  get tabCount() {
+    return this.tabs.size;
+  }
+};
+
+// packages/daemon/src/index.ts
+var DAEMON_DIR = process.env.BB_BROWSER_HOME || path2.join(os.homedir(), ".bb-browser");
+var DAEMON_JSON = path2.join(DAEMON_DIR, "daemon.json");
+var DEFAULT_CDP_PORT = 19825;
+function parseOptions() {
+  const { values } = parseArgs({
+    allowPositionals: true,
+    options: {
+      host: {
+        type: "string",
+        short: "H",
+        default: DAEMON_HOST
+      },
+      port: {
+        type: "string",
+        short: "p",
+        default: String(DAEMON_PORT)
+      },
+      "cdp-host": {
+        type: "string",
+        default: "127.0.0.1"
+      },
+      "cdp-port": {
+        type: "string",
+        default: String(DEFAULT_CDP_PORT)
+      },
+      token: {
+        type: "string",
+        default: ""
+      },
+      help: {
+        type: "boolean",
+        short: "h",
+        default: false
+      }
+    }
+  });
+  if (values.help) {
+    console.error(`
+bb-browser-daemon \u2014 CDP-direct backend for bb-browser
+
+Usage:
+  bb-browser-daemon [options]
+
+Options:
+  -H, --host <host>          HTTP server host (default: ${DAEMON_HOST})
+  -p, --port <port>          HTTP server port (default: ${DAEMON_PORT})
+      --cdp-host <host>      Chrome CDP host (default: 127.0.0.1)
+      --cdp-port <port>      Chrome CDP port (default: ${DEFAULT_CDP_PORT})
+      --token <token>        Bearer auth token (auto-generated if empty)
+  -h, --help                 Show this help message
+
+Endpoints:
+  POST /command      Send command and get result (via CDP)
+  GET  /status       Daemon health + per-tab stats
+  POST /shutdown     Graceful shutdown
+`);
+    process.exit(0);
+  }
+  let token = values.token ?? "";
+  const host = values.host ?? DAEMON_HOST;
+  if (!token && host !== "127.0.0.1" && host !== "localhost") {
+    token = randomBytes(16).toString("hex");
+  }
+  return {
+    host: values.host ?? DAEMON_HOST,
+    port: parseInt(values.port ?? String(DAEMON_PORT), 10),
+    cdpHost: values["cdp-host"] ?? "127.0.0.1",
+    cdpPort: parseInt(values["cdp-port"] ?? String(DEFAULT_CDP_PORT), 10),
+    token
+  };
+}
+function writeDaemonJson(info) {
+  try {
+    mkdirSync(DAEMON_DIR, { recursive: true });
+    writeFileSync(DAEMON_JSON, JSON.stringify(info), { mode: 384 });
+  } catch {
+  }
+}
+function cleanupDaemonJson() {
+  if (existsSync(DAEMON_JSON)) {
+    try {
+      unlinkSync(DAEMON_JSON);
+    } catch {
+    }
+  }
+}
+async function discoverCdpPort(host, port) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2e3);
+    try {
+      const response = await fetch(`http://${host}:${port}/json/version`, {
+        signal: controller.signal
+      });
+      if (response.ok) {
+        return { host, port };
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  } catch {
+  }
+  const managedPortFile = path2.join(DAEMON_DIR, "browser", "cdp-port");
+  try {
+    const rawPort = readFileSync2(managedPortFile, "utf8").trim();
+    const managedPort = parseInt(rawPort, 10);
+    if (Number.isInteger(managedPort) && managedPort > 0) {
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 2e3);
+        try {
+          const response = await fetch(`http://127.0.0.1:${managedPort}/json/version`, {
+            signal: controller.signal
+          });
+          if (response.ok) {
+            return { host: "127.0.0.1", port: managedPort };
+          }
+        } finally {
+          clearTimeout(timer);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  throw new Error(
+    `Cannot connect to Chrome CDP at ${host}:${port}. Make sure Chrome is running with --remote-debugging-port=${port}`
+  );
+}
+async function main() {
+  const options = parseOptions();
+  const tabManager = new TabStateManager();
+  let cdpEndpoint;
+  try {
+    cdpEndpoint = await discoverCdpPort(options.cdpHost, options.cdpPort);
+  } catch (error) {
+    console.error(
+      `[Daemon] ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
+  const cdp = new CdpConnection(cdpEndpoint.host, cdpEndpoint.port, tabManager);
+  let shuttingDown = false;
+  const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.error("[Daemon] Shutting down...");
+    cdp.disconnect();
+    await httpServer.stop();
+    cleanupDaemonJson();
+    process.exit(0);
+  };
+  const httpServer = new HttpServer({
+    host: options.host,
+    port: options.port,
+    token: options.token,
+    cdp,
+    onShutdown: shutdown
+  });
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await httpServer.start();
+  writeDaemonJson({
+    pid: process.pid,
+    host: options.host,
+    port: options.port,
+    token: options.token
+  });
+  console.error(
+    `[Daemon] HTTP server listening on http://${options.host}:${options.port}`
+  );
+  console.error(`[Daemon] Auth token: ${options.token}`);
+  console.error(
+    `[Daemon] Connecting to Chrome CDP at ${cdpEndpoint.host}:${cdpEndpoint.port}...`
+  );
+  try {
+    await cdp.connect();
+    const tabCount = tabManager.tabCount;
+    console.error(
+      `[Daemon] CDP connected, monitoring ${tabCount} tab(s)`
+    );
+  } catch (error) {
+    console.error(
+      `[Daemon] Failed to connect to CDP: ${error instanceof Error ? error.message : String(error)}`
+    );
+    console.error("[Daemon] HTTP server is running, but commands will fail until CDP connects.");
+  }
+}
+main().catch((error) => {
+  console.error("[Daemon] Fatal error:", error);
+  cleanupDaemonJson();
+  process.exit(1);
+});
+//# sourceMappingURL=daemon.js.map