@docyrus/docyrus 0.0.59 → 0.0.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@docyrus/docyrus",
-  "version": "0.0.59",
+  "version": "0.0.62",
   "private": false,
   "description": "Docyrus API CLI",
   "main": "./main.js",

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

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { ensureDaemon, cdp, evaluate, clickAt, 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 isCoordMode = positional.length >= 2 && /^\d+$/.test(positional[0]) && /^\d+$/.test(positional[1]);
+const target = isCoordMode ? null : positional[0];
+
+if (!target && !isCoordMode) {
+  console.log("Usage: browser-click.js <@ref|selector|x y> [--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 {
+  if (isCoordMode) {
+    clickAt(parseInt(positional[0], 10), parseInt(positional[1], 10));
+    const url = evaluate("window.location.href");
+    console.log(JSON.stringify({ mode: getMode(), clicked: `${positional[0]},${positional[1]}`, url }));
+  } else if (target.startsWith("@e")) {
+    const { selector, xpath } = resolveRef(target);
+    // Wait for element, then get its center coordinates for compositor-level click
+    waitForCondition(`!!document.querySelector(${JSON.stringify(selector)}) || !!document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue`, timeout);
+
+    const coords = evaluate(`(() => {
+      let el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) el = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+      if (!el) return null;
+      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}`); }
+    clickAt(coords.x, coords.y);
+    const url = evaluate("window.location.href");
+    console.log(JSON.stringify({ mode: getMode(), clicked: target, url }));
+  } else {
+    // CSS selector — get center coords and click at compositor level
+    waitForCondition(`!!document.querySelector(${JSON.stringify(target)})`, timeout);
+    const coords = evaluate(`(() => {
+      const el = document.querySelector(${JSON.stringify(target)});
+      if (!el) return null;
+      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}`); }
+    clickAt(coords.x, coords.y);
+    const url = evaluate("window.location.href");
+    console.log(JSON.stringify({ mode: getMode(), clicked: target, url }));
+  }
+} catch (e) {
+  console.error(`✗ Click failed: ${e.message}`);
+  process.exit(1);
+}

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

@@ -0,0 +1,236 @@
+/**
+ * Browser client — thin HTTP wrapper for the browser daemon.
+ * Replaces browser-connect.js. All operations are raw CDP via daemon HTTP API.
+ *
+ * Usage:
+ *   import { cdp, ensureDaemon, drainEvents, shutdown, getMode } from "./browser-client.js";
+ *
+ *   await ensureDaemon();
+ *   const { root } = cdp("DOM.getDocument", { depth: -1 });
+ *   const screenshot = cdp("Page.captureScreenshot", { format: "png" });
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { execFileSync, spawn } from "node:child_process";
+import { request } from "node:http";
+
+const DOCYRUS_DIR = join(process.cwd(), ".docyrus");
+const DAEMON_INFO_FILE = join(DOCYRUS_DIR, "browser-daemon.json");
+const DEFAULT_PORT = 9333;
+
+let daemonPort = null;
+
+// ── Daemon Lifecycle ────────────────────────────────────────────────────────
+
+function getDaemonPort() {
+  if (daemonPort) { return daemonPort; }
+  try {
+    const info = JSON.parse(readFileSync(DAEMON_INFO_FILE, "utf8"));
+    daemonPort = info.port;
+    return daemonPort;
+  } catch {
+    return DEFAULT_PORT;
+  }
+}
+
+function isDaemonAlive() {
+  try {
+    const res = httpSync("GET", "/health");
+    return res?.alive === true;
+  } catch {
+    return false;
+  }
+}
+
+export async function ensureDaemon() {
+  if (isDaemonAlive()) { return; }
+
+  // Find the daemon script
+  const candidates = [
+    join(import.meta.dirname || ".", "browser-daemon.js"),
+    join(process.cwd(), "apps/api-cli/resources/browser-tools/browser-daemon.js"),
+  ];
+  const daemonScript = candidates.find((c) => existsSync(c));
+  if (!daemonScript) {
+    throw new Error("Cannot find browser-daemon.js");
+  }
+
+  // Start daemon in background
+  const child = spawn(process.execPath, [daemonScript], {
+    detached: true,
+    stdio: "ignore",
+    cwd: process.cwd(),
+    env: { ...process.env },
+  });
+  child.unref();
+
+  // Wait for daemon to be ready (up to 30s)
+  for (let i = 0; i < 60; i++) {
+    await new Promise((r) => setTimeout(r, 500));
+    if (isDaemonAlive()) {
+      return;
+    }
+  }
+  throw new Error("Daemon failed to start within 30 seconds");
+}
+
+// ── HTTP Communication (synchronous) ────────────────────────────────────────
+
+function httpSync(method, path, body) {
+  const port = getDaemonPort();
+  const url = `http://127.0.0.1:${port}${path}`;
+
+  // Use node -e to make a synchronous HTTP call (matches browser-harness pattern)
+  const script = method === "GET"
+    ? `fetch("${url}").then(r=>r.json()).then(d=>process.stdout.write(JSON.stringify(d))).catch(e=>{process.stderr.write(e.message);process.exit(1)})`
+    : `fetch("${url}",{method:"POST",headers:{"Content-Type":"application/json"},body:${JSON.stringify(JSON.stringify(body))}}).then(r=>r.json()).then(d=>process.stdout.write(JSON.stringify(d))).catch(e=>{process.stderr.write(e.message);process.exit(1)})`;
+
+  const result = execFileSync(process.execPath, ["-e", script], {
+    encoding: "utf8",
+    timeout: 35_000,
+  });
+
+  return JSON.parse(result);
+}
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Send a raw CDP command through the daemon.
+ * @param {string} method - CDP method (e.g., "Page.navigate", "Runtime.evaluate")
+ * @param {object} params - CDP params
+ * @param {string} [sid] - Optional session ID override
+ * @returns {object} CDP result
+ */
+export function cdp(method, params = {}, sid) {
+  const req = { method, params };
+  if (sid) { req.sessionId = sid; }
+  const resp = httpSync("POST", "/", req);
+  if (resp.error) {
+    throw new Error(`CDP ${method}: ${resp.error}`);
+  }
+  return resp.result || {};
+}
+
+/** Drain buffered CDP events from the daemon. */
+export function drainEvents() {
+  const resp = httpSync("POST", "/", { meta: "drain_events" });
+  return resp.events || [];
+}
+
+/** Get the current daemon session ID. */
+export function getSession() {
+  const resp = httpSync("POST", "/", { meta: "session" });
+  return resp.sessionId;
+}
+
+/** Set the daemon's active session. */
+export function setSession(sid) {
+  httpSync("POST", "/", { meta: "set_session", sessionId: sid });
+}
+
+/** Gracefully shut down the daemon. */
+export function shutdown() {
+  try { httpSync("POST", "/", { meta: "shutdown" }); } catch {}
+}
+
+/** Get daemon health info. */
+export function health() {
+  return httpSync("GET", "/health");
+}
+
+/** Get current mode (local/remote). */
+export function getMode() {
+  try {
+    const h = health();
+    return h.mode || "local";
+  } catch {
+    return "unknown";
+  }
+}
+
+// ── High-Level Helpers (common CDP sequences) ───────────────────────────────
+
+/** Navigate to a URL and wait for load. */
+export function navigate(url, waitUntil = "load") {
+  const result = cdp("Page.navigate", { url });
+  if (waitUntil) {
+    // Wait for loadEventFired or DOMContentLoaded via events
+    const deadline = Date.now() + 15_000;
+    const targetEvent = waitUntil === "domcontentloaded" ? "Page.domContentEventFired" : "Page.loadEventFired";
+    while (Date.now() < deadline) {
+      const evts = drainEvents();
+      if (evts.some((e) => e.method === targetEvent)) { break; }
+      execFileSync(process.execPath, ["-e", "setTimeout(()=>{},200)"], { timeout: 1000 });
+    }
+  }
+  return result;
+}
+
+/** Evaluate JS in the page and return the value. */
+export function evaluate(expression) {
+  const result = cdp("Runtime.evaluate", {
+    expression,
+    returnByValue: true,
+    awaitPromise: true,
+  });
+  if (result.exceptionDetails) {
+    throw new Error(result.exceptionDetails.text || result.exceptionDetails.exception?.description || "JS evaluation error");
+  }
+  return result.result?.value;
+}
+
+/** Take a screenshot and return base64 data. */
+export function captureScreenshot(options = {}) {
+  return cdp("Page.captureScreenshot", {
+    format: "png",
+    captureBeyondViewport: options.full || false,
+    ...options,
+  });
+}
+
+/** Get page info (URL, title, viewport, scroll). */
+export function pageInfo() {
+  return evaluate(`({
+    url: window.location.href,
+    title: document.title,
+    viewportWidth: window.innerWidth,
+    viewportHeight: window.innerHeight,
+    scrollX: Math.round(window.scrollX),
+    scrollY: Math.round(window.scrollY),
+    pageWidth: document.documentElement.scrollWidth,
+    pageHeight: document.documentElement.scrollHeight,
+    readyState: document.readyState,
+  })`);
+}
+
+/** Click at compositor-level coordinates (passes through iframes/shadow DOM). */
+export function clickAt(x, y) {
+  cdp("Input.dispatchMouseEvent", { type: "mousePressed", x, y, button: "left", clickCount: 1 });
+  cdp("Input.dispatchMouseEvent", { type: "mouseReleased", x, y, button: "left", clickCount: 1 });
+}
+
+/** Type text via CDP Input.insertText. */
+export function typeText(text) {
+  cdp("Input.insertText", { text });
+}
+
+/** Press a key via CDP Input.dispatchKeyEvent. */
+export function pressKey(key) {
+  cdp("Input.dispatchKeyEvent", { type: "keyDown", key });
+  cdp("Input.dispatchKeyEvent", { type: "keyUp", key });
+}
+
+/** Wait for a JS condition to be true. */
+export function waitForCondition(expression, timeout = 15000) {
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    try {
+      const val = evaluate(expression);
+      if (val) { return val; }
+    } catch {}
+    execFileSync(process.execPath, ["-e", "setTimeout(()=>{},250)"], { timeout: 1000 });
+  }
+  throw new Error(`waitForCondition timed out: ${expression}`);
+}

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

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+import { unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { shutdown, getMode } from "./browser-client.js";
+
+const kill = process.argv.includes("--kill");
+
+try {
+  const mode = getMode();
+  shutdown();
+
+  // Clear cached remote session
+  try { unlinkSync(join(process.cwd(), ".docyrus", "browser-session.json")); } catch {}
+
+  console.log(JSON.stringify({ mode, closed: true, daemonStopped: true }));
+} catch {
+  console.log(JSON.stringify({ closed: true, note: "Daemon was not running" }));
+}

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

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+import { ensureDaemon, evaluate, drainEvents, getMode } from "./browser-client.js";
+import { execFileSync } from "node:child_process";
+
+const args = process.argv.slice(2);
+const levelIdx = args.indexOf("--level");
+const listenIdx = args.indexOf("--listen");
+const filterLevel = levelIdx !== -1 ? args[levelIdx + 1] : null;
+const listenMs = listenIdx !== -1 ? parseInt(args[listenIdx + 1], 10) : null;
+
+await ensureDaemon();
+
+try {
+  if (listenMs) {
+    // Listen mode: collect Runtime.consoleAPICalled events from daemon buffer
+    const messages = [];
+    const deadline = Date.now() + listenMs;
+
+    while (Date.now() < deadline) {
+      const evts = drainEvents();
+      for (const evt of evts) {
+        if (evt.method === "Runtime.consoleAPICalled") {
+          const level = evt.params.type || "log";
+          if (filterLevel && level !== filterLevel) {continue;}
+          const text = (evt.params.args || []).map((a) => a.value ?? a.description ?? "").join(" ");
+          messages.push({ level, text, url: evt.params.stackTrace?.callFrames?.[0]?.url || null });
+        }
+        if (evt.method === "Runtime.exceptionThrown") {
+          if (!filterLevel || filterLevel === "error") {
+            messages.push({ level: "error", text: evt.params.exceptionDetails?.text || "Unknown error", url: null });
+          }
+        }
+      }
+      execFileSync(process.execPath, ["-e", "setTimeout(()=>{},200)"], { timeout: 1000 });
+    }
+
+    console.log(JSON.stringify({ mode: getMode(), count: messages.length, messages }));
+  } else {
+    // Snapshot mode: install interceptor and read captured logs
+    const messages = evaluate(`(() => {
+      const filterLevel = ${filterLevel ? JSON.stringify(filterLevel) : "null"};
+      if (!window.__docyrus_console_log) {
+        window.__docyrus_console_log = [];
+        const MAX = 100;
+        const orig = {};
+        for (const level of ["log", "warn", "error", "info", "debug"]) {
+          orig[level] = console[level];
+          console[level] = (...args) => {
+            window.__docyrus_console_log.push({
+              level,
+              text: args.map(a => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" "),
+              timestamp: Date.now(),
+            });
+            if (window.__docyrus_console_log.length > MAX) window.__docyrus_console_log.shift();
+            orig[level](...args);
+          };
+        }
+        window.addEventListener("error", e => {
+          window.__docyrus_console_log.push({ level: "error", text: e.message || String(e), timestamp: Date.now() });
+        });
+      }
+      let logs = window.__docyrus_console_log || [];
+      if (filterLevel) logs = logs.filter(l => l.level === filterLevel);
+      return logs.slice(-50);
+    })()`);
+
+    console.log(JSON.stringify({ mode: getMode(), count: messages.length, messages }));
+  }
+} catch (e) {
+  console.error(`✗ Console capture failed: ${e.message}`);
+  process.exit(1);
+}

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

@@ -1,99 +1,60 @@
 #!/usr/bin/env node
 
-import { Readability } from "@mozilla/readability";
 import { JSDOM } from "jsdom";
+import { Readability } from "@mozilla/readability";
 import TurndownService from "turndown";
 import { gfm } from "turndown-plugin-gfm";
-import { connectBrowser } from "./browser-connect.js";
+import { ensureDaemon, navigate, cdp, evaluate, getMode } from "./browser-client.js";
 
-// Global timeout - exit if script takes too long
 const TIMEOUT = 30000;
-setTimeout(() => {
-  console.error("✗ Timeout after 30s");
-  process.exit(1);
-}, TIMEOUT).unref();
+setTimeout(() => { console.error("✗ Timeout after 30s"); process.exit(1); }, TIMEOUT).unref();
 
 const url = process.argv[2];
-
 if (!url) {
   console.log("Usage: browser-content.js <url>");
-  console.log("\nExtracts readable content from a URL as markdown.");
-  console.log("\nExamples:");
-  console.log("  browser-content.js https://example.com");
-  console.log("  browser-content.js https://en.wikipedia.org/wiki/Rust_(programming_language)");
   process.exit(1);
 }
 
-const { browser: b, mode, session } = await connectBrowser();
-
-const p = (await b.pages()).at(-1);
-if (!p) {
-  console.error("✗ No active tab found");
-  process.exit(1);
-}
+await ensureDaemon();
 
-await Promise.race([
-  p.goto(url, { waitUntil: "networkidle2" }),
-  new Promise((r) => setTimeout(r, 10000)),
-]).catch(() => {});
+try {
+  navigate(url, "load");
 
-// Get HTML via CDP (works even with TrustedScriptURL restrictions)
-const client = await p.createCDPSession();
-const { root } = await client.send("DOM.getDocument", { depth: -1, pierce: true });
-const { outerHTML } = await client.send("DOM.getOuterHTML", { nodeId: root.nodeId });
-await client.detach();
+  // Get HTML via CDP DOM (bypasses TrustedScriptURL restrictions)
+  const { root } = cdp("DOM.getDocument", { depth: -1, pierce: true });
+  const { outerHTML } = cdp("DOM.getOuterHTML", { nodeId: root.nodeId });
 
-const finalUrl = p.url();
+  const finalUrl = evaluate("window.location.href");
 
-// Extract with Readability
-const doc = new JSDOM(outerHTML, { url: finalUrl });
-const reader = new Readability(doc.window.document);
-const article = reader.parse();
+  // Extract with Readability
+  const doc = new JSDOM(outerHTML, { url: finalUrl });
+  const reader = new Readability(doc.window.document);
+  const article = reader.parse();
 
-// Convert to markdown
-function htmlToMarkdown(html) {
-  const turndown = new TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced" });
-  turndown.use(gfm);
-  turndown.addRule("removeEmptyLinks", {
-    filter: (node) => node.nodeName === "A" && !node.textContent?.trim(),
-    replacement: () => "",
-  });
-  return turndown
-    .turndown(html)
-    .replace(/\[\\?\[\s*\\?\]\]\([^)]*\)/g, "")
-    .replace(/ +/g, " ")
-    .replace(/\s+,/g, ",")
-    .replace(/\s+\./g, ".")
-    .replace(/\n{3,}/g, "\n\n")
-    .trim();
-}
+  function htmlToMarkdown(html) {
+    const turndown = new TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced" });
+    turndown.use(gfm);
+    turndown.addRule("removeEmptyLinks", {
+      filter: (node) => node.nodeName === "A" && !node.textContent?.trim(),
+      replacement: () => "",
+    });
+    return turndown.turndown(html).replace(/\[\\?\[\s*\\?\]\]\([^)]*\)/g, "").replace(/ +/g, " ").replace(/\s+,/g, ",").replace(/\s+\./g, ".").replace(/\n{3,}/g, "\n\n").trim();
+  }
 
-let content;
-if (article && article.content) {
-  content = htmlToMarkdown(article.content);
-} else {
-  // Fallback
-  const fallbackDoc = new JSDOM(outerHTML, { url: finalUrl });
-  const fallbackBody = fallbackDoc.window.document;
-  fallbackBody.querySelectorAll("script, style, noscript, nav, header, footer, aside").forEach((el) => el.remove());
-  const main = fallbackBody.querySelector("main, article, [role='main'], .content, #content") || fallbackBody.body;
-  const fallbackHtml = main?.innerHTML || "";
-  if (fallbackHtml.trim().length > 100) {
-    content = htmlToMarkdown(fallbackHtml);
+  let content;
+  if (article?.content) {
+    content = htmlToMarkdown(article.content);
   } else {
-    content = "(Could not extract content)";
+    const fallbackDoc = new JSDOM(outerHTML, { url: finalUrl });
+    const fallbackBody = fallbackDoc.window.document;
+    fallbackBody.querySelectorAll("script, style, noscript, nav, header, footer, aside").forEach((el) => el.remove());
+    const main = fallbackBody.querySelector("main, article, [role='main'], .content, #content") || fallbackBody.body;
+    const fallbackHtml = main?.innerHTML || "";
+    content = fallbackHtml.trim().length > 100 ? htmlToMarkdown(fallbackHtml) : "(Could not extract content)";
   }
-}
 
-// Content command outputs markdown directly (not wrapped in JSON) since
-// the extracted text is the primary payload and is consumed as plain text.
-console.log(`URL: ${finalUrl}`);
-if (article?.title) {console.log(`Title: ${article.title}`);}
-if (mode === "remote" && session?.devtoolsFrontendUrl) {
-  console.log(`DevTools: ${session.devtoolsFrontendUrl}`);
+  console.log(JSON.stringify({ mode: getMode(), url: finalUrl, title: article?.title || null, content }));
+} catch (e) {
+  console.error(`✗ Content extraction failed: ${e.message}`);
+  process.exit(1);
 }
-console.log(`Mode: ${mode}`);
-console.log("");
-console.log(content);
-
-process.exit(0);

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

@@ -1,22 +1,27 @@
 #!/usr/bin/env node
 
-import { connectBrowser } from "./browser-connect.js";
+import { ensureDaemon, cdp, getMode } from "./browser-client.js";
 
-const { browser: b, mode, session } = await connectBrowser();
+const args = process.argv.slice(2);
+const nameIdx = args.indexOf("--name");
+const domainIdx = args.indexOf("--domain");
+const filterName = nameIdx !== -1 ? args[nameIdx + 1] : null;
+const filterDomain = domainIdx !== -1 ? args[domainIdx + 1] : null;
 
-const p = (await b.pages()).at(-1);
+await ensureDaemon();
 
-if (!p) {
-  console.error("✗ No active tab found");
-  process.exit(1);
-}
+try {
+  let { cookies } = cdp("Network.getCookies");
 
-const cookies = await p.cookies();
+  if (filterName) {
+    cookies = cookies.filter((c) => c.name === filterName);
+  }
+  if (filterDomain) {
+    cookies = cookies.filter((c) => c.domain.includes(filterDomain));
+  }
 
-const result = { mode, cookies };
-if (session?.devtoolsFrontendUrl) {
-  result.devtoolsFrontendUrl = session.devtoolsFrontendUrl;
+  console.log(JSON.stringify({ mode: getMode(), cookies }));
+} catch (e) {
+  console.error(`✗ Cookies failed: ${e.message}`);
+  process.exit(1);
 }
-console.log(JSON.stringify(result));
-
-await b.disconnect();