@docyrus/docyrus 0.0.59 → 0.0.62

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

@@ -0,0 +1,452 @@
+#!/usr/bin/env node
+
+/**
+ * Persistent browser daemon — holds a raw CDP WebSocket connection and exposes
+ * an HTTP API on localhost. Eliminates per-command connection overhead.
+ *
+ * Protocol (all POST /):
+ *   { method, params?, sessionId? }   → { result }          CDP call
+ *   { meta: "drain_events" }          → { events: [...] }   buffered CDP events
+ *   { meta: "session" }               → { sessionId }       current session
+ *   { meta: "set_session", sessionId } → { sessionId }      change session
+ *   { meta: "shutdown" }              → { ok: true }         graceful stop
+ *
+ * GET /health → { alive, mode, sessionId, uptime }
+ *
+ * Env vars:
+ *   BROWSER_DAEMON_PORT (default 9333)
+ *   DOCYRUS_BROWSER_SANDBOX=1 for remote mode
+ *   DOCYRUS_SANDBOX_APP_ID for remote mode
+ */
+
+import { createServer } from "node:http";
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import WebSocket from "ws";
+
+// Allow self-signed certs for localhost dev servers
+if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === undefined) {
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+}
+
+// ── Config ──────────────────────────────────────────────────────────────────
+
+const PORT = parseInt(process.env.BROWSER_DAEMON_PORT || "9333", 10);
+const IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+const EVENT_BUFFER_MAX = 500;
+const CDP_CONNECT_RETRIES = 12;
+const CDP_RETRY_DELAY_MS = 5000;
+const DOCYRUS_DIR = join(process.cwd(), ".docyrus");
+const PID_FILE = join(DOCYRUS_DIR, "browser-daemon.pid");
+const DAEMON_INFO_FILE = join(DOCYRUS_DIR, "browser-daemon.json");
+
+// ── State ───────────────────────────────────────────────────────────────────
+
+let ws = null;
+let sessionId = null;
+let mode = "local";
+let messageId = 0;
+const pending = new Map();       // id → { resolve, reject, timer }
+const events = [];               // circular buffer
+let idleTimer = null;
+const startTime = Date.now();
+
+// ── CDP WebSocket Layer ─────────────────────────────────────────────────────
+
+function getLocalWsUrl() {
+  // Try localhost:9222 debug endpoint first
+  try {
+    const resp = execFileSync("node", [
+      "-e", "fetch('http://localhost:9222/json/version').then(r=>r.json()).then(d=>console.log(d.webSocketDebuggerUrl)).catch(()=>process.exit(1))",
+    ], { encoding: "utf8", timeout: 5000 }).trim();
+    if (resp.startsWith("ws://")) {
+      return resp;
+    }
+  } catch {}
+  throw new Error("Cannot find Chrome WebSocket URL. Is Chrome running with --remote-debugging-port=9222?");
+}
+
+async function getRemoteWsUrl() {
+  // Read cached session
+  const sessionFile = join(DOCYRUS_DIR, "browser-session.json");
+  try {
+    const cached = JSON.parse(readFileSync(sessionFile, "utf8"));
+    if (cached?.expiresAt && new Date(cached.expiresAt).getTime() - 30_000 > Date.now()) {
+      return { wsUrl: cached.browserWSEndpoint, authHeader: cached.authHeader, session: cached };
+    }
+  } catch {}
+
+  // Resolve app ID
+  const appId = process.env.DOCYRUS_SANDBOX_APP_ID
+    || (() => {
+      try {
+        return JSON.parse(readFileSync(join(DOCYRUS_DIR, "browser.json"), "utf8")).appId;
+      } catch { return null; }
+    })();
+
+  if (!appId) {
+    throw new Error("Sandbox mode but no app ID. Set DOCYRUS_SANDBOX_APP_ID or .docyrus/browser.json");
+  }
+
+  // Resolve API base URL and access token from auth store
+  let apiBaseUrl = "https://localhost:3366";
+  let accessToken = null;
+
+  try {
+    const configFile = join(DOCYRUS_DIR, "config.json");
+    const config = JSON.parse(readFileSync(configFile, "utf8"));
+    const envId = config.activeEnvironmentId || "dev";
+    const env = (config.environments || []).find((e) => e.id === envId);
+    if (env?.apiBaseUrl) { apiBaseUrl = env.apiBaseUrl; }
+  } catch {}
+
+  // Try local auth, then global auth
+  for (const authPath of [join(DOCYRUS_DIR, "auth.json"), join(process.env.HOME || "", ".docyrus", "auth.json")]) {
+    if (accessToken) {break;}
+    try {
+      const auth = JSON.parse(readFileSync(authPath, "utf8"));
+      // Auth store keys may have /v1 suffix
+      for (const key of [apiBaseUrl, `${apiBaseUrl}/v1`]) {
+        const active = auth.activeByApiBaseUrl?.[key];
+        const userId = typeof active === "string" ? active : active?.userId;
+        if (!userId) {continue;}
+        // Tokens are in the profiles array, matched by userId + apiBaseUrl
+        const profiles = Array.isArray(auth.profiles) ? auth.profiles : [];
+        const profile = profiles.find((p) => p.userId === userId && (p.apiBaseUrl === key || p.apiBaseUrl === apiBaseUrl));
+        if (profile?.accessToken) { accessToken = profile.accessToken; apiBaseUrl = profile.apiBaseUrl.replace(/\/v1$/, ""); break; }
+      }
+    } catch {}
+  }
+
+  if (!accessToken) {
+    throw new Error("No access token found. Run 'docyrus auth login' first.");
+  }
+
+  // Call createBrowserSession API directly
+  const url = `${apiBaseUrl}/v1/ai/sandbox/app/${appId}/createBrowserSession`;
+  log(`creating browser session: POST ${url}`);
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+    },
+    // Allow self-signed certs for local dev
+    ...(apiBaseUrl.includes("localhost") ? { dispatcher: undefined } : {}),
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`createBrowserSession failed (${resp.status}): ${body}`);
+  }
+
+  const respBody = await resp.json();
+  // API wraps response in { success, data } — unwrap if present
+  const data = respBody.data || respBody;
+  const now = Date.now();
+  const session = {
+    ...data,
+    createdAt: new Date(now).toISOString(),
+    expiresAt: new Date(now + (data.keepAliveMs || 600_000)).toISOString(),
+  };
+
+  mkdirSync(DOCYRUS_DIR, { recursive: true, mode: 0o700 });
+  writeFileSync(join(DOCYRUS_DIR, "browser-session.json"), JSON.stringify(session, null, 2) + "\n", { mode: 0o600 });
+
+  return { wsUrl: data.browserWSEndpoint, authHeader: data.authHeader, session };
+}
+
+function isSandboxMode() {
+  if (process.env.DOCYRUS_BROWSER_SANDBOX === "1") { return true; }
+  try {
+    return JSON.parse(readFileSync(join(DOCYRUS_DIR, "browser.json"), "utf8")).mode === "sandbox";
+  } catch { return false; }
+}
+
+async function connectCdp() {
+  let wsUrl, headers = {};
+
+  if (isSandboxMode()) {
+    mode = "remote";
+    const remote = await getRemoteWsUrl();
+    wsUrl = remote.wsUrl;
+    if (remote.authHeader) {
+      headers.Authorization = remote.authHeader;
+    }
+  } else {
+    mode = "local";
+    wsUrl = getLocalWsUrl();
+  }
+
+  log(`connecting to ${wsUrl} (mode=${mode})`);
+
+  for (let attempt = 0; attempt < CDP_CONNECT_RETRIES; attempt++) {
+    try {
+      await new Promise((resolve, reject) => {
+        ws = new WebSocket(wsUrl, { headers });
+        ws.once("open", resolve);
+        ws.once("error", reject);
+        setTimeout(() => reject(new Error("timeout")), CDP_RETRY_DELAY_MS);
+      });
+
+      ws.on("message", onCdpMessage);
+      ws.on("close", () => { log("CDP WebSocket closed"); ws = null; });
+      ws.on("error", (e) => { log(`CDP WebSocket error: ${e.message}`); });
+
+      log("CDP connected");
+      await attachFirstPage();
+      return;
+    } catch (e) {
+      log(`connect attempt ${attempt + 1}/${CDP_CONNECT_RETRIES} failed: ${e.message}`);
+      ws = null;
+      if (attempt < CDP_CONNECT_RETRIES - 1) {
+        await sleep(CDP_RETRY_DELAY_MS);
+      }
+    }
+  }
+  throw new Error("CDP connection failed after all retries");
+}
+
+function onCdpMessage(raw) {
+  const msg = JSON.parse(raw.toString());
+
+  // Response to a pending request
+  if (msg.id !== undefined && pending.has(msg.id)) {
+    const { resolve, reject, timer } = pending.get(msg.id);
+    pending.delete(msg.id);
+    clearTimeout(timer);
+    if (msg.error) {
+      reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+    } else {
+      resolve(msg.result || {});
+    }
+    return;
+  }
+
+  // CDP event — buffer it
+  if (msg.method) {
+    events.push({
+      method: msg.method,
+      params: msg.params || {},
+      sessionId: msg.sessionId || null,
+    });
+    while (events.length > EVENT_BUFFER_MAX) {
+      events.shift();
+    }
+  }
+}
+
+function sendCdp(method, params = {}, sid) {
+  if (!ws || ws.readyState !== WebSocket.OPEN) {
+    return Promise.reject(new Error("CDP WebSocket not connected"));
+  }
+
+  const id = ++messageId;
+  const msg = { id, method, params };
+  if (sid) { msg.sessionId = sid; }
+
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      reject(new Error(`CDP call ${method} timed out (30s)`));
+    }, 30_000);
+
+    pending.set(id, { resolve, reject, timer });
+    ws.send(JSON.stringify(msg));
+  });
+}
+
+async function attachFirstPage() {
+  const { targetInfos } = await sendCdp("Target.getTargets");
+  const pages = targetInfos.filter((t) =>
+    t.type === "page" && !t.url.startsWith("chrome://") && !t.url.startsWith("chrome-extension://") && !t.url.startsWith("devtools://"),
+  );
+
+  let targetId;
+  if (pages.length > 0) {
+    targetId = pages[0].targetId;
+  } else {
+    const created = await sendCdp("Target.createTarget", { url: "about:blank" });
+    targetId = created.targetId;
+  }
+
+  const attached = await sendCdp("Target.attachToTarget", { targetId, flatten: true });
+  sessionId = attached.sessionId;
+  log(`attached target=${targetId} session=${sessionId}`);
+
+  // Enable key CDP domains
+  for (const domain of ["Page", "DOM", "Runtime", "Network"]) {
+    try { await sendCdp(`${domain}.enable`, {}, sessionId); }
+    catch (e) { log(`enable ${domain}: ${e.message}`); }
+  }
+}
+
+async function reattachOnStale() {
+  log("session stale, re-attaching...");
+  try {
+    await attachFirstPage();
+    return true;
+  } catch (e) {
+    log(`re-attach failed: ${e.message}`);
+    return false;
+  }
+}
+
+// ── HTTP Server ─────────────────────────────────────────────────────────────
+
+function resetIdle() {
+  if (idleTimer) { clearTimeout(idleTimer); }
+  idleTimer = setTimeout(() => {
+    log("idle timeout, shutting down");
+    shutdown();
+  }, IDLE_TIMEOUT_MS);
+}
+
+async function handleRequest(req) {
+  resetIdle();
+
+  // Health check
+  if (req.meta === "health" || req._health) {
+    return { alive: true, mode, sessionId, uptime: Math.round((Date.now() - startTime) / 1000) };
+  }
+
+  // Meta commands
+  if (req.meta === "drain_events") {
+    const out = [...events];
+    events.length = 0;
+    return { events: out };
+  }
+  if (req.meta === "session") {
+    return { sessionId };
+  }
+  if (req.meta === "set_session") {
+    sessionId = req.sessionId;
+    return { sessionId };
+  }
+  if (req.meta === "shutdown") {
+    setTimeout(() => shutdown(), 100);
+    return { ok: true };
+  }
+
+  // CDP call
+  const { method, params = {}, sessionId: sid } = req;
+  if (!method) {
+    return { error: "missing 'method' field" };
+  }
+
+  // Target.* calls go without session (browser-level)
+  const effectiveSid = method.startsWith("Target.") ? undefined : (sid || sessionId);
+
+  try {
+    const result = await sendCdp(method, params, effectiveSid);
+    return { result };
+  } catch (e) {
+    // Auto-recover stale session
+    if (e.message?.includes("not found") && effectiveSid === sessionId) {
+      if (await reattachOnStale()) {
+        try {
+          const result = await sendCdp(method, params, sessionId);
+          return { result };
+        } catch (e2) {
+          return { error: e2.message };
+        }
+      }
+    }
+    return { error: e.message };
+  }
+}
+
+function startHttpServer() {
+  const server = createServer(async(req, res) => {
+    // CORS for local dev
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Content-Type", "application/json");
+
+    if (req.method === "GET" && req.url === "/health") {
+      const result = await handleRequest({ _health: true });
+      res.writeHead(200);
+      res.end(JSON.stringify(result));
+      return;
+    }
+
+    if (req.method !== "POST") {
+      res.writeHead(405);
+      res.end(JSON.stringify({ error: "POST only" }));
+      return;
+    }
+
+    let body = "";
+    req.on("data", (chunk) => { body += chunk; });
+    req.on("end", async() => {
+      try {
+        const parsed = JSON.parse(body);
+        const result = await handleRequest(parsed);
+        res.writeHead(result.error ? 500 : 200);
+        res.end(JSON.stringify(result));
+      } catch (e) {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: e.message }));
+      }
+    });
+  });
+
+  server.listen(PORT, "127.0.0.1", () => {
+    log(`HTTP server on http://127.0.0.1:${PORT} (mode=${mode})`);
+    writeDaemonInfo();
+  });
+
+  server.on("error", (e) => {
+    if (e.code === "EADDRINUSE") {
+      log(`port ${PORT} already in use — daemon may already be running`);
+      process.exit(0);
+    }
+    throw e;
+  });
+
+  return server;
+}
+
+// ── Lifecycle ───────────────────────────────────────────────────────────────
+
+function writeDaemonInfo() {
+  mkdirSync(DOCYRUS_DIR, { recursive: true, mode: 0o700 });
+  writeFileSync(PID_FILE, String(process.pid), { mode: 0o600 });
+  writeFileSync(DAEMON_INFO_FILE, JSON.stringify({ pid: process.pid, port: PORT, mode, startedAt: new Date().toISOString() }, null, 2) + "\n", { mode: 0o600 });
+}
+
+function shutdown() {
+  log("shutting down");
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    ws.close();
+  }
+  try { unlinkSync(PID_FILE); } catch {}
+  try { unlinkSync(DAEMON_INFO_FILE); } catch {}
+  process.exit(0);
+}
+
+function log(msg) {
+  const ts = new Date().toISOString().slice(11, 23);
+  process.stderr.write(`[daemon ${ts}] ${msg}\n`);
+}
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// ── Main ────────────────────────────────────────────────────────────────────
+
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+
+try {
+  await connectCdp();
+  startHttpServer();
+  resetIdle();
+} catch (e) {
+  log(`fatal: ${e.message}`);
+  try { unlinkSync(PID_FILE); } catch {}
+  try { unlinkSync(DAEMON_INFO_FILE); } catch {}
+  process.exit(1);
+}

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

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+/**
+ * Read @docyrus/devtools state from the active page.
+ *
+ * Usage:
+ *   browser-devtools.js state           # full devtools state
+ *   browser-devtools.js errors          # API errors
+ *   browser-devtools.js issues          # detected issues
+ *   browser-devtools.js console         # console entries
+ *   browser-devtools.js console --level error
+ */
+
+import { ensureDaemon, evaluate, getMode } from "./browser-client.js";
+
+const args = process.argv.slice(2);
+const subcommand = args[0];
+const levelIdx = args.indexOf("--level");
+const level = levelIdx !== -1 ? args[levelIdx + 1] : null;
+
+if (!subcommand || !["state", "errors", "issues", "console"].includes(subcommand)) {
+  console.log("Usage: browser-devtools.js <state|errors|issues|console> [--level <level>]");
+  console.log("\nSubcommands:");
+  console.log("  state     Full @docyrus/devtools state");
+  console.log("  errors    Collected API errors");
+  console.log("  issues    Detected API usage issues");
+  console.log("  console   Console entries (optionally filtered by --level)");
+  process.exit(1);
+}
+
+await ensureDaemon();
+
+try {
+  const available = evaluate("typeof window.__DOCYRUS_DEVTOOLS__ !== 'undefined'");
+  if (!available) {
+    console.error("✗ @docyrus/devtools is not loaded on this page");
+    process.exit(1);
+  }
+
+  let result;
+  switch (subcommand) {
+    case "state":
+      result = evaluate("window.__DOCYRUS_DEVTOOLS__.getState()");
+      break;
+    case "errors":
+      result = evaluate("window.__DOCYRUS_DEVTOOLS__.getErrors()");
+      break;
+    case "issues":
+      result = evaluate("window.__DOCYRUS_DEVTOOLS__.getIssues()");
+      break;
+    case "console":
+      result = level
+        ? evaluate(`window.__DOCYRUS_DEVTOOLS__.getConsoleEntries(${JSON.stringify(level)})`)
+        : evaluate("window.__DOCYRUS_DEVTOOLS__.getConsoleEntries()");
+      break;
+  }
+
+  console.log(JSON.stringify({ mode: getMode(), [subcommand]: result }));
+} catch (e) {
+  console.error(`✗ Devtools failed: ${e.message}`);
+  process.exit(1);
+}

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

@@ -1,34 +1,28 @@
 #!/usr/bin/env node
 
-import { connectBrowser } from "./browser-connect.js";
+import { ensureDaemon, evaluate, getMode } from "./browser-client.js";
+
+const args = process.argv.slice(2);
+const timeoutIdx = args.indexOf("--timeout");
+const codeArgs = timeoutIdx === -1 ? args : args.filter((_, i) => i !== timeoutIdx && i !== timeoutIdx + 1);
+const code = codeArgs.join(" ");
 
-const code = process.argv.slice(2).join(" ");
 if (!code) {
-  console.log("Usage: browser-eval.js 'code'");
+  console.log("Usage: browser-eval.js 'code' [--timeout <ms>]");
   console.log("\nExamples:");
   console.log('  browser-eval.js "document.title"');
-  console.log('  browser-eval.js "document.querySelectorAll(\'a\').length"');
+  console.log('  browser-eval.js "const x = 1; const y = 2; return x + y"');
   process.exit(1);
 }
 
-const { browser: b, mode, session } = await connectBrowser();
-
-const p = (await b.pages()).at(-1);
+await ensureDaemon();
 
-if (!p) {
-  console.error("✗ No active tab found");
+try {
+  // Wrap: try as expression first, fall back to multi-statement function body
+  const wrappedCode = `(async () => { try { return (${code}) } catch { ${code} } })()`;
+  const result = evaluate(wrappedCode);
+  console.log(JSON.stringify({ mode: getMode(), result }));
+} catch (e) {
+  console.error(`✗ Eval failed: ${e.message}`);
   process.exit(1);
 }
-
-const evalResult = await p.evaluate((c) => {
-  const AsyncFunction = (async() => {}).constructor;
-  return new AsyncFunction(`return (${c})`)();
-}, code);
-
-const output = { mode, result: evalResult };
-if (session?.devtoolsFrontendUrl) {
-  output.devtoolsFrontendUrl = session.devtoolsFrontendUrl;
-}
-console.log(JSON.stringify(output));
-
-await b.disconnect();

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

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { ensureDaemon, evaluate, clickAt, typeText, cdp, 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 === undefined) {
+  console.log('Usage: browser-fill.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.");
+  }
+}
+
+function resolveSelector(target) {
+  if (target.startsWith("@e")) {
+    const { selector, xpath } = resolveRef(target);
+    return { selector, xpath };
+  }
+  return { selector: target, xpath: null };
+}
+
+await ensureDaemon();
+
+try {
+  const { selector, xpath } = resolveSelector(target);
+  const selectorExpr = JSON.stringify(selector);
+  const xpathExpr = xpath ? JSON.stringify(xpath) : "null";
+
+  waitForCondition(`!!document.querySelector(${selectorExpr}) || (${xpathExpr} && !!document.evaluate(${xpathExpr}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue)`, timeout);
+
+  // Focus the element and select all existing content
+  const coords = evaluate(`(() => {
+    let el = document.querySelector(${selectorExpr});
+    if (!el && ${xpathExpr}) el = document.evaluate(${xpathExpr}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+    if (!el) return null;
+    el.focus();
+    if (el.select) el.select();
+    const r = el.getBoundingClientRect();
+    return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+  })()`);
+
+  if (!coords) { throw new Error(`Element not found: ${target}`); }
+
+  // Triple-click to select all, then type replacement
+  cdp("Input.dispatchMouseEvent", { type: "mousePressed", x: coords.x, y: coords.y, button: "left", clickCount: 3 });
+  cdp("Input.dispatchMouseEvent", { type: "mouseReleased", x: coords.x, y: coords.y, button: "left", clickCount: 3 });
+  typeText(value);
+
+  console.log(JSON.stringify({ mode: getMode(), filled: target, value }));
+} catch (e) {
+  console.error(`✗ Fill failed: ${e.message}`);
+  process.exit(1);
+}

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

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+import { ensureDaemon, pageInfo, getMode } from "./browser-client.js";
+
+await ensureDaemon();
+
+try {
+  const info = pageInfo();
+  console.log(JSON.stringify({ mode: getMode(), ...info }));
+} catch (e) {
+  console.error(`✗ Info failed: ${e.message}`);
+  process.exit(1);
+}