@docyrus/docyrus 0.0.58 → 0.0.60

package/resources/browser-tools/browser-nav.js

@@ -1,38 +1,37 @@
 #!/usr/bin/env node
 
-import { connectBrowser } from "./browser-connect.js";
+import { ensureDaemon, navigate, cdp, getMode, evaluate } from "./browser-client.js";
 
 const args = process.argv.slice(2);
 const newTab = args.includes("--new");
 const reload = args.includes("--reload");
-const url = args.find(a => !a.startsWith("--"));
+const url = args.find((a) => !a.startsWith("--"));
 
 if (!url) {
   console.log("Usage: browser-nav.js <url> [--new] [--reload]");
-  console.log("\nExamples:");
-  console.log("  browser-nav.js https://example.com          # Navigate current tab");
-  console.log("  browser-nav.js https://example.com --new    # Open in new tab");
-  console.log("  browser-nav.js https://example.com --reload # Navigate and force reload");
   process.exit(1);
 }
 
-const { browser: b, mode, session } = await connectBrowser();
+await ensureDaemon();
 
-if (newTab) {
-  const p = await b.newPage();
-  await p.goto(url, { waitUntil: "domcontentloaded" });
-} else {
-  const p = (await b.pages()).at(-1);
-  await p.goto(url, { waitUntil: "domcontentloaded" });
-  if (reload) {
-    await p.reload({ waitUntil: "domcontentloaded" });
+try {
+  if (newTab) {
+    const { targetId } = cdp("Target.createTarget", { url });
+    const { sessionId } = cdp("Target.attachToTarget", { targetId, flatten: true });
+    cdp("Page.enable", {}, sessionId);
+    // Update daemon's active session to the new tab
+    const { default: { setSession } } = await import("./browser-client.js");
+    setSession(sessionId);
+  } else {
+    navigate(url, "domcontentloaded");
+    if (reload) {
+      cdp("Page.reload");
+    }
   }
-}
 
-const result = { mode, url };
-if (session?.devtoolsFrontendUrl) {
-  result.devtoolsFrontendUrl = session.devtoolsFrontendUrl;
+  const currentUrl = evaluate("window.location.href");
+  console.log(JSON.stringify({ mode: getMode(), url: currentUrl }));
+} catch (e) {
+  console.error(`✗ Navigation failed: ${e.message}`);
+  process.exit(1);
 }
-console.log(JSON.stringify(result));
-
-await b.disconnect();

package/resources/browser-tools/browser-network.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+/**
+ * Inspect network requests captured by the daemon's event buffer.
+ * Network.enable is called when the daemon attaches, so requests are buffered automatically.
+ *
+ * Usage:
+ *   browser-network.js                         # all requests
+ *   browser-network.js --method POST           # only POST requests
+ *   browser-network.js --status 4xx            # only 4xx responses
+ *   browser-network.js --url "/api/"           # URL substring filter
+ *   browser-network.js --listen 5000           # listen for 5 seconds
+ */
+
+import { ensureDaemon, drainEvents, getMode } from "./browser-client.js";
+import { execFileSync } from "node:child_process";
+
+const args = process.argv.slice(2);
+const methodIdx = args.indexOf("--method");
+const statusIdx = args.indexOf("--status");
+const urlIdx = args.indexOf("--url");
+const listenIdx = args.indexOf("--listen");
+const filterMethod = methodIdx !== -1 ? args[methodIdx + 1]?.toUpperCase() : null;
+const filterStatus = statusIdx !== -1 ? args[statusIdx + 1] : null;
+const filterUrl = urlIdx !== -1 ? args[urlIdx + 1] : null;
+const listenMs = listenIdx !== -1 ? parseInt(args[listenIdx + 1], 10) : null;
+
+await ensureDaemon();
+
+function matchStatus(code, pattern) {
+  if (!pattern) {return true;}
+  if (pattern.endsWith("xx")) {
+    const prefix = pattern.slice(0, -2);
+    return String(code).startsWith(prefix);
+  }
+  return String(code) === pattern;
+}
+
+try {
+  const requests = new Map(); // requestId → { method, url, status, ... }
+
+  function processEvents(evts) {
+    for (const evt of evts) {
+      if (evt.method === "Network.requestWillBeSent") {
+        const { requestId, request } = evt.params;
+        requests.set(requestId, {
+          method: request.method,
+          url: request.url,
+          status: null,
+          statusText: null,
+          type: evt.params.type || null,
+        });
+      }
+      if (evt.method === "Network.responseReceived") {
+        const { requestId, response } = evt.params;
+        const req = requests.get(requestId);
+        if (req) {
+          req.status = response.status;
+          req.statusText = response.statusText;
+        }
+      }
+    }
+  }
+
+  if (listenMs) {
+    const deadline = Date.now() + listenMs;
+    while (Date.now() < deadline) {
+      processEvents(drainEvents());
+      execFileSync(process.execPath, ["-e", "setTimeout(()=>{},200)"], { timeout: 1000 });
+    }
+  } else {
+    processEvents(drainEvents());
+  }
+
+  let entries = [...requests.values()];
+
+  if (filterMethod) {
+    entries = entries.filter((r) => r.method === filterMethod);
+  }
+  if (filterStatus) {
+    entries = entries.filter((r) => r.status !== null && matchStatus(r.status, filterStatus));
+  }
+  if (filterUrl) {
+    entries = entries.filter((r) => r.url.includes(filterUrl));
+  }
+
+  console.log(JSON.stringify({ mode: getMode(), count: entries.length, requests: entries }));
+} catch (e) {
+  console.error(`✗ Network inspection failed: ${e.message}`);
+  process.exit(1);
+}

package/resources/browser-tools/browser-run-script.js

@@ -1,53 +1,35 @@
 #!/usr/bin/env node
 
 /**
- * Run a user-supplied CDP script on the active browser session.
+ * Run a user-supplied script on the active browser session.
+ * The script receives `cdp`, `evaluate`, and helpers from browser-client.js.
  *
- * Usage: node browser-run-script.js <script> [--appId <id>] [--appSlug <slug>]
- *
- * The script file receives `browser` (Puppeteer Browser) and `page` (first Page)
- * as function arguments. Whatever the script returns is printed as JSON to stdout.
+ * Usage: browser-run-script.js <script.js>
  */
 
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { connectBrowser } from "./browser-connect.js";
+import { ensureDaemon, cdp, evaluate, navigate, captureScreenshot, clickAt, typeText, pressKey, pageInfo, drainEvents, getMode, waitForCondition } from "./browser-client.js";
 
 const args = process.argv.slice(2);
-
-const scriptPath = args.find((a) => !a.startsWith("--") && args[args.indexOf(a) - 1]?.startsWith("--") === false) ?? args[0];
+const scriptPath = args.find((a) => !a.startsWith("--")) ?? args[0];
 
 if (!scriptPath || scriptPath.startsWith("--")) {
-  console.error("Usage: browser-run-script.js <script.js> [--appId <id>] [--appSlug <slug>]");
-  console.error("\nThe script receives `browser` and `page` as arguments.");
-  console.error("\nExample script:");
-  console.error('  await page.goto("https://example.com");');
-  console.error("  return { title: await page.title() };");
+  console.error("Usage: browser-run-script.js <script.js>");
+  console.error("\nThe script receives: cdp, evaluate, navigate, captureScreenshot, clickAt, typeText, pressKey, pageInfo, drainEvents, waitForCondition");
   process.exit(1);
 }
 
-const { browser, mode, session } = await connectBrowser();
+await ensureDaemon();
 
 try {
-  const page = await browser.newPage();
-
   const userCode = readFileSync(resolve(scriptPath), "utf8");
   const AsyncFunction = (async() => {}).constructor;
-  const fn = new AsyncFunction("browser", "page", userCode);
-  const scriptResult = await fn(browser, page);
+  const fn = new AsyncFunction("cdp", "evaluate", "navigate", "captureScreenshot", "clickAt", "typeText", "pressKey", "pageInfo", "drainEvents", "waitForCondition", userCode);
+  const result = await fn(cdp, evaluate, navigate, captureScreenshot, clickAt, typeText, pressKey, pageInfo, drainEvents, waitForCondition);
 
-  const output = { mode, result: scriptResult ?? { ok: true } };
-  if (session?.devtoolsFrontendUrl) {
-    output.devtoolsFrontendUrl = session.devtoolsFrontendUrl;
-  }
-  console.log(JSON.stringify(output, null, 2));
+  console.log(JSON.stringify({ mode: getMode(), result: result ?? { ok: true } }, null, 2));
 } catch (e) {
-  console.error("✗ CDP script failed:", e.message);
+  console.error(`✗ Script failed: ${e.message}`);
   process.exit(1);
-} finally {
-  try {
-    await browser.disconnect();
-  } catch {
-    // Session may have already expired.
-  }
 }

package/resources/browser-tools/browser-screenshot.js

@@ -2,27 +2,27 @@
 
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { connectBrowser } from "./browser-connect.js";
-
-const { browser: b, mode, session } = await connectBrowser();
-
-const p = (await b.pages()).at(-1);
-
-if (!p) {
-  console.error("✗ No active tab found");
+import { writeFileSync } from "node:fs";
+import { ensureDaemon, captureScreenshot, getMode } from "./browser-client.js";
+
+const args = process.argv.slice(2);
+const fullPage = args.includes("--full");
+const base64 = args.includes("--base64");
+
+await ensureDaemon();
+
+try {
+  const { data } = captureScreenshot({ full: fullPage });
+
+  if (base64) {
+    console.log(JSON.stringify({ mode: getMode(), base64: data, fullPage }));
+  } else {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const filepath = join(tmpdir(), `screenshot-${timestamp}.png`);
+    writeFileSync(filepath, Buffer.from(data, "base64"));
+    console.log(JSON.stringify({ mode: getMode(), path: filepath, fullPage }));
+  }
+} catch (e) {
+  console.error(`✗ Screenshot failed: ${e.message}`);
   process.exit(1);
 }
-
-const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-const filename = `screenshot-${timestamp}.png`;
-const filepath = join(tmpdir(), filename);
-
-await p.screenshot({ path: filepath });
-
-const result = { mode, path: filepath };
-if (session?.devtoolsFrontendUrl) {
-  result.devtoolsFrontendUrl = session.devtoolsFrontendUrl;
-}
-console.log(JSON.stringify(result));
-
-await b.disconnect();

package/resources/browser-tools/browser-select.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { ensureDaemon, evaluate, getMode, waitForCondition } from "./browser-client.js";
+
+const args = process.argv.slice(2);
+const timeoutIdx = args.indexOf("--timeout");
+const timeout = timeoutIdx !== -1 ? parseInt(args[timeoutIdx + 1], 10) : 5000;
+const positional = args.filter((a, i) => !a.startsWith("--") && args[i - 1] !== "--timeout");
+const target = positional[0];
+const value = positional[1];
+
+if (!target || !value) {
+  console.log('Usage: browser-select.js <@ref|selector> "value" [--timeout <ms>]');
+  process.exit(1);
+}
+
+function resolveRef(ref) {
+  try {
+    const refs = JSON.parse(readFileSync(join(process.cwd(), ".docyrus", "browser-refs.json"), "utf8"));
+    const entry = refs[ref];
+    if (!entry) { throw new Error(`Unknown ref "${ref}"`); }
+    return entry;
+  } catch (e) {
+    if (e.message.includes("Unknown ref")) {throw e;}
+    throw new Error("No snapshot refs found. Run \"docyrus browser snapshot\" first.");
+  }
+}
+
+await ensureDaemon();
+
+try {
+  const { selector, xpath } = target.startsWith("@e") ? resolveRef(target) : { selector: target, xpath: null };
+  const selectorExpr = JSON.stringify(selector);
+  const xpathExpr = xpath ? JSON.stringify(xpath) : "null";
+  const valExpr = JSON.stringify(value);
+
+  waitForCondition(`!!document.querySelector(${selectorExpr}) || (${xpathExpr} && !!document.evaluate(${xpathExpr}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue)`, timeout);
+
+  const selected = evaluate(`(() => {
+    let el = document.querySelector(${selectorExpr});
+    if (!el && ${xpathExpr}) el = document.evaluate(${xpathExpr}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+    if (!el || el.tagName !== "SELECT") throw new Error("Target is not a <select> element");
+    for (const opt of el.options) {
+      if (opt.textContent.trim() === ${valExpr} || opt.value === ${valExpr}) {
+        el.value = opt.value;
+        el.dispatchEvent(new Event("change", { bubbles: true }));
+        return opt.textContent.trim();
+      }
+    }
+    throw new Error("Option " + ${valExpr} + " not found");
+  })()`);
+
+  console.log(JSON.stringify({ mode: getMode(), selected: target, value: selected }));
+} catch (e) {
+  console.error(`✗ Select failed: ${e.message}`);
+  process.exit(1);
+}

package/resources/browser-tools/browser-snapshot.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { ensureDaemon, evaluate, getMode } from "./browser-client.js";
+
+const args = process.argv.slice(2);
+const includeAll = args.includes("--all");
+const selectorIdx = args.indexOf("--selector");
+const scopeSelector = selectorIdx !== -1 ? args[selectorIdx + 1] : null;
+
+await ensureDaemon();
+
+try {
+  const elements = evaluate(`(() => {
+    const root = ${scopeSelector ? `document.querySelector(${JSON.stringify(scopeSelector)})` : "document.body"};
+    if (!root) return [];
+
+    const INTERACTIVE_TAGS = new Set(["A", "BUTTON", "INPUT", "SELECT", "TEXTAREA", "DETAILS", "SUMMARY"]);
+    const INTERACTIVE_ROLES = new Set(["button", "link", "textbox", "checkbox", "radio", "combobox", "listbox", "menuitem", "option", "searchbox", "slider", "spinbutton", "switch", "tab"]);
+    const results = [];
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {
+      acceptNode(node) {
+        if (node.offsetParent === null && node.tagName !== "BODY" && node.tagName !== "HTML") {
+          const style = getComputedStyle(node);
+          if (style.display === "none" || style.visibility === "hidden") return NodeFilter.FILTER_REJECT;
+        }
+        return NodeFilter.FILTER_ACCEPT;
+      },
+    });
+
+    let node = walker.currentNode;
+    while (node) {
+      if (node.nodeType === Node.ELEMENT_NODE) {
+        const tag = node.tagName;
+        const role = node.getAttribute("role");
+        const isInteractive = INTERACTIVE_TAGS.has(tag) || INTERACTIVE_ROLES.has(role) || node.hasAttribute("onclick") || node.hasAttribute("tabindex") || node.contentEditable === "true";
+
+        if (${includeAll} || isInteractive) {
+          const entry = { tag: tag.toLowerCase(), text: (node.textContent || "").trim().slice(0, 120) || null };
+          if (tag === "INPUT") { entry.type = node.type || "text"; entry.name = node.name || null; entry.value = node.value || null; entry.placeholder = node.placeholder || null; }
+          else if (tag === "SELECT") { entry.name = node.name || null; const sel = node.options?.[node.selectedIndex]; entry.value = sel?.textContent?.trim() || null; }
+          else if (tag === "TEXTAREA") { entry.name = node.name || null; entry.value = node.value || null; entry.placeholder = node.placeholder || null; }
+          else if (tag === "A") { entry.href = node.href || null; }
+          if (role) entry.role = role;
+          if (node.disabled) entry.disabled = true;
+          if (node.id) entry.id = node.id;
+
+          let selector = tag.toLowerCase();
+          if (node.id) selector = "#" + node.id;
+          else {
+            if (node.name) selector += "[name=\\"" + node.name + "\\"]";
+            if (node.type && tag === "INPUT") selector += "[type=\\"" + node.type + "\\"]";
+            if (node.className && typeof node.className === "string") {
+              const cls = node.className.trim().split(/\\s+/).slice(0, 2).join(".");
+              if (cls) selector += "." + cls;
+            }
+          }
+          entry._selector = selector;
+
+          // XPath for reliable targeting
+          const parts = [];
+          let cur = node;
+          while (cur && cur !== document) {
+            let idx = 1;
+            let sib = cur.previousElementSibling;
+            while (sib) { if (sib.tagName === cur.tagName) idx++; sib = sib.previousElementSibling; }
+            parts.unshift(cur.tagName.toLowerCase() + "[" + idx + "]");
+            cur = cur.parentElement;
+          }
+          entry._xpath = "/" + parts.join("/");
+
+          results.push(entry);
+        }
+      }
+      node = walker.nextNode();
+    }
+    return results;
+  })()`);
+
+  const snapshot = [];
+  const refMap = {};
+  for (let i = 0; i < elements.length; i++) {
+    const ref = `@e${i + 1}`;
+    const { _selector, _xpath, ...display } = elements[i];
+    display.ref = ref;
+    snapshot.push(display);
+    refMap[ref] = { selector: _selector, xpath: _xpath };
+  }
+
+  const docyrusDir = join(process.cwd(), ".docyrus");
+  mkdirSync(docyrusDir, { recursive: true, mode: 0o700 });
+  writeFileSync(join(docyrusDir, "browser-refs.json"), JSON.stringify(refMap, null, 2) + "\n", { mode: 0o600 });
+
+  const url = evaluate("window.location.href");
+  console.log(JSON.stringify({ mode: getMode(), url, count: snapshot.length, snapshot }));
+} catch (e) {
+  console.error(`✗ Snapshot failed: ${e.message}`);
+  process.exit(1);
+}

package/resources/browser-tools/browser-start.js

@@ -1,8 +1,14 @@
 #!/usr/bin/env node
 
-import { spawn, execSync } from "node:child_process";
-import puppeteer from "puppeteer-core";
-import { isSandboxMode, connectBrowser } from "./browser-connect.js";
+/**
+ * Start the browser daemon. In local mode, launches Chrome if not running.
+ * In sandbox mode, the daemon creates a Cloudflare Browser Rendering session.
+ */
+
+import { spawn, execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, unlinkSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { ensureDaemon, health } from "./browser-client.js";
 
 const useProfile = process.argv[2] === "--profile";
 
@@ -13,91 +19,101 @@ if (process.argv[2] && process.argv[2] !== "--profile") {
   process.exit(1);
 }
 
-// Sandbox mode: create a remote Cloudflare Browser Rendering session
-if (isSandboxMode()) {
-  const { session } = await connectBrowser();
-
-  const result = {
-    mode: "remote",
-    sessionId: session.sessionId,
-    tabUrl: session.tabUrl,
-    devtoolsFrontendUrl: session.devtoolsFrontendUrl,
-  };
-  console.log(JSON.stringify(result));
-  process.exit(0);
-}
+// In sandbox mode, just ensure the daemon is running (it handles session creation)
+const isSandbox = process.env.DOCYRUS_BROWSER_SANDBOX === "1" || (() => {
+  try {
+    return JSON.parse(readFileSync(join(process.cwd(), ".docyrus", "browser.json"), "utf8")).mode === "sandbox";
+  } catch { return false; }
+})();
 
-// Local mode: start Chrome on :9222
-// Note: execSync calls below use only hardcoded paths, not user input.
-const SCRAPING_DIR = `${process.env.HOME}/.cache/browser-tools`;
-
-// Check if already running on :9222
-try {
-  const browser = await puppeteer.connect({
-    browserURL: "http://localhost:9222",
-    defaultViewport: null,
-  });
-  await browser.disconnect();
-  console.log(JSON.stringify({ mode: "local", status: "already_running" }));
-  process.exit(0);
-} catch {}
-
-// Setup profile directory
-execSync(`mkdir -p "${SCRAPING_DIR}"`, { stdio: "ignore" });
-
-// Remove SingletonLock to allow new instance
-try {
-  execSync(`rm -f "${SCRAPING_DIR}/SingletonLock" "${SCRAPING_DIR}/SingletonSocket" "${SCRAPING_DIR}/SingletonCookie"`, { stdio: "ignore" });
-} catch {}
-
-if (useProfile) {
-  console.error("Syncing profile...");
-  execSync(
-    `rsync -a --delete \
-			--exclude='SingletonLock' \
-			--exclude='SingletonSocket' \
-			--exclude='SingletonCookie' \
-			--exclude='*/Sessions/*' \
-			--exclude='*/Current Session' \
-			--exclude='*/Current Tabs' \
-			--exclude='*/Last Session' \
-			--exclude='*/Last Tabs' \
-			"${process.env.HOME}/Library/Application Support/Google/Chrome/" "${SCRAPING_DIR}/"`,
-    { stdio: "pipe" },
-  );
-}
+if (!isSandbox) {
+  // Local mode: ensure Chrome is running on :9222 before starting daemon
+  const SCRAPING_DIR = `${process.env.HOME}/.cache/browser-tools`;
 
-// Start Chrome with flags to force new instance
-spawn(
-  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
-  [
-    "--remote-debugging-port=9222",
-    `--user-data-dir=${SCRAPING_DIR}`,
-    "--no-first-run",
-    "--no-default-browser-check",
-  ],
-  { detached: true, stdio: "ignore" },
-).unref();
-
-// Wait for Chrome to be ready
-let connected = false;
-for (let i = 0; i < 30; i++) {
-  try {
-    const browser = await puppeteer.connect({
-      browserURL: "http://localhost:9222",
-      defaultViewport: null,
-    });
-    await browser.disconnect();
-    connected = true;
-    break;
-  } catch {
-    await new Promise((r) => setTimeout(r, 500));
+  function detectChromePath() {
+    if (process.env.CHROME_PATH) { return process.env.CHROME_PATH; }
+    const platform = process.platform;
+    const candidates = [];
+    if (platform === "darwin") {
+      candidates.push(
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        "/Applications/Chromium.app/Contents/MacOS/Chromium",
+        "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+      );
+    } else if (platform === "linux") {
+      candidates.push("/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/chromium", "/usr/bin/chromium-browser", "/snap/bin/chromium");
+    } else if (platform === "win32") {
+      const pf = process.env["PROGRAMFILES"] || "C:\\Program Files";
+      const pf86 = process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)";
+      const la = process.env.LOCALAPPDATA || "";
+      candidates.push(`${pf}\\Google\\Chrome\\Application\\chrome.exe`, `${pf86}\\Google\\Chrome\\Application\\chrome.exe`, `${la}\\Google\\Chrome\\Application\\chrome.exe`);
+    }
+    for (const bin of ["google-chrome", "chromium", "chromium-browser"]) {
+      try {
+        const found = execFileSync(process.platform === "win32" ? "where" : "which", [bin], { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }).trim().split("\n")[0];
+        if (found) { candidates.push(found); }
+      } catch {}
+    }
+    return candidates.find((c) => existsSync(c)) || null;
   }
-}
 
-if (!connected) {
-  console.error("✗ Failed to connect to Chrome");
-  process.exit(1);
+  function detectProfilePath() {
+    if (process.platform === "darwin") { return `${process.env.HOME}/Library/Application Support/Google/Chrome/`; }
+    if (process.platform === "linux") { return `${process.env.HOME}/.config/google-chrome/`; }
+    if (process.platform === "win32") { return `${process.env.LOCALAPPDATA || ""}\\Google\\Chrome\\User Data\\`; }
+    return null;
+  }
+
+  // Check if Chrome is already reachable
+  let chromeRunning = false;
+  try {
+    const resp = execFileSync("node", ["-e", "fetch('http://localhost:9222/json/version').then(r=>r.json()).then(()=>console.log('ok')).catch(()=>process.exit(1))"], { encoding: "utf8", timeout: 3000 });
+    chromeRunning = resp.trim() === "ok";
+  } catch {}
+
+  if (!chromeRunning) {
+    const chromePath = detectChromePath();
+    if (!chromePath) {
+      console.error("✗ Could not find Chrome or Chromium. Set CHROME_PATH to the browser executable.");
+      process.exit(1);
+    }
+
+    mkdirSync(SCRAPING_DIR, { recursive: true });
+    for (const lock of ["SingletonLock", "SingletonSocket", "SingletonCookie"]) {
+      try { unlinkSync(`${SCRAPING_DIR}/${lock}`); } catch {}
+    }
+
+    if (useProfile) {
+      const profilePath = detectProfilePath();
+      if (!profilePath) {
+        console.error("✗ Could not detect Chrome profile path.");
+        process.exit(1);
+      }
+      console.error("Syncing profile...");
+      execFileSync("rsync", ["-a", "--delete", "--exclude=SingletonLock", "--exclude=SingletonSocket", "--exclude=SingletonCookie", "--exclude=*/Sessions/*", "--exclude=*/Current Session", "--exclude=*/Current Tabs", "--exclude=*/Last Session", "--exclude=*/Last Tabs", profilePath, `${SCRAPING_DIR}/`], { stdio: "pipe" });
+    }
+
+    spawn(chromePath, ["--remote-debugging-port=9222", `--user-data-dir=${SCRAPING_DIR}`, "--no-first-run", "--no-default-browser-check"], { detached: true, stdio: "ignore" }).unref();
+
+    // Wait for Chrome to be reachable
+    for (let i = 0; i < 30; i++) {
+      try {
+        execFileSync("node", ["-e", "fetch('http://localhost:9222/json/version').then(r=>r.json()).then(()=>console.log('ok')).catch(()=>process.exit(1))"], { encoding: "utf8", timeout: 3000 });
+        chromeRunning = true;
+        break;
+      } catch {
+        await new Promise((r) => setTimeout(r, 500));
+      }
+    }
+
+    if (!chromeRunning) {
+      console.error("✗ Chrome failed to start");
+      process.exit(1);
+    }
+  }
 }
 
-console.log(JSON.stringify({ mode: "local", status: "started", profile: useProfile }));
+// Start/ensure daemon
+await ensureDaemon();
+const info = health();
+console.log(JSON.stringify({ mode: info.mode, status: "ready", sessionId: info.sessionId, profile: useProfile }));