@duckmind/dm-windows-x64 0.60.6 → 0.60.8

package/extensions/greedysearch-dm/bin/cdp.mjs

@@ -1,44 +1,775 @@
-#!/usr/bin/env node
-import{spawn as MQ}from"node:child_process";import{createHash as YQ}from"node:crypto";import{basename as XQ}from"node:path";function m(Q=process.env,z=process.execPath){let $=Q.GREEDY_SEARCH_NODE||Q.NODE_BINARY||Q.NODE;if($?.trim())return $.trim();let V=XQ(z||"").toLowerCase();if(V==="node"||V==="node.exe")return z;return"node"}import{existsSync as d,mkdirSync as wQ,readdirSync as jQ,readFileSync as v,unlinkSync as O,writeFileSync as s}from"node:fs";import e from"node:net";import{homedir as f,platform as u,tmpdir as kQ}from"node:os";import{join as k}from"node:path";import{existsSync as y,mkdirSync as WQ,readFileSync as l,writeFileSync as ZQ}from"node:fs";import{homedir as KQ}from"node:os";import{join as i}from"node:path";import{tmpdir as qQ}from"node:os";function BQ(Q,z=9222){let $=Number.parseInt(String(Q??""),10);return Number.isInteger($)&&$>1024&&$<65535?$:z}var JQ=qQ().replaceAll("\\","/"),tQ=BQ(process.env.GREEDY_SEARCH_PORT),U=(process.env.GREEDY_SEARCH_PROFILE_DIR||process.env.CDP_PROFILE_DIR||`${JQ}/greedysearch-chrome-profile`).replaceAll("\\","/"),dQ=`${U}/DevToolsActivePort`,sQ=process.env.GREEDY_SEARCH_PID_FILE||`${U}/browser.pid`,N=process.env.CDP_PAGES_CACHE||`${U}/cdp-pages.json`,eQ=process.env.GREEDY_SEARCH_MODE_FILE||`${U}/browser-mode`,Q0=process.env.GREEDY_SEARCH_METADATA_FILE||`${U}/browser-metadata.json`,$0=process.env.GREEDY_SEARCH_LAUNCH_LOCK_FILE||`${U}/browser-launch.lock`,V0=process.env.GREEDY_SEARCH_ACTIVITY_FILE||`${U}/browser-last-activity`,j=(process.env.CDP_SOCKET_DIR||`${U}/cdp-sockets`).replaceAll("\\","/"),z0=`${U}/visible-recovery.jsonl`,R=i(KQ(),".dm"),M=i(R,"greedyconfig"),P=["perplexity","google","chatgpt","gemini"],D="gemini";function bQ(){try{if(y(M)){let Q=l(M,"utf8"),z=JSON.parse(Q);if(Array.isArray(z.engines)&&z.engines.length>0&&z.engines.every(($)=>typeof $==="string")){let $=z.engines.filter((X)=>C[X]),V=z.engines.filter((X)=>!C[X]);if(V.length>0)process.stderr.write(`[greedysearch] Warning: ignoring unknown engine(s) in ${M}: ${V.join(", ")}
-[greedysearch] Available engines: ${Object.keys(C).join(", ")}
-`);if($.length>0)return $;process.stderr.write(`[greedysearch] Warning: no valid engines in ${M}, falling back to defaults: ${P.join(", ")}
-`)}}}catch{}return P}function HQ(){try{if(!y(R))WQ(R,{recursive:!0});if(!y(M))ZQ(M,JSON.stringify({engines:P,synthesizer:D},null,2)+`
-`,"utf8")}catch{}}HQ();var p=["gemini","chatgpt"];function UQ(){try{if(y(M)){let Q=l(M,"utf8"),z=JSON.parse(Q);if(typeof z.synthesizer==="string"){let $=z.synthesizer.toLowerCase();if(p.includes($))return $;process.stderr.write(`[greedysearch] Warning: unknown synthesizer "${z.synthesizer}" in ${M}
-[greedysearch] Available synthesizers: ${p.join(", ")}
-[greedysearch] Falling back to default: ${D}
-`)}}}catch{}return D}var C={perplexity:"perplexity.mjs",p:"perplexity.mjs",bing:"bing-copilot.mjs",b:"bing-copilot.mjs",google:"google-ai.mjs",g:"google-ai.mjs",gemini:"gemini.mjs",gem:"gemini.mjs",chatgpt:"chatgpt.mjs",gpt:"chatgpt.mjs","semantic-scholar":"semantic-scholar.mjs",semanticscholar:"semantic-scholar.mjs",s2:"semantic-scholar.mjs",logically:"logically.mjs",log:"logically.mjs"},X0=bQ();var W0=UQ(),Z0=Math.max(1,Number.parseInt(process.env.GREEDY_FETCH_CONCURRENCY||"5",10)||5);process.env.CDP_PROFILE_DIR=U;var c=90000,QQ=30000,a=1200000,LQ=20,o=300,r=8,OQ=YQ("sha256").update(j).digest("hex").slice(0,12);function $Q(Q){if(u()==="win32")return`\\\\.\\pipe\\dm-cdp-${OQ}-${Q}`;return wQ(j,{recursive:!0}),k(j,`${Q}.sock`)}function GQ(){let Q=u();if(Q==="win32")return k(f(),"AppData","Local","Google","Chrome","User Data","DevToolsActivePort");if(Q==="darwin")return k(f(),"Library","Application Support","Google","Chrome","DevToolsActivePort");return k(f(),".config","google-chrome","DevToolsActivePort")}function VQ(){let Q=process.env.CDP_PROFILE_DIR;if(Q){let V=`${Q.replaceAll("\\","/")}/DevToolsActivePort`;if(d(V)){let X=v(V,"utf8").trim().split(`
-`);return`ws://localhost:${X[0]}${X[1]}`}throw Error(`GreedySearch DevToolsActivePort not found at ${V}. Refusing to fall back to the main Chrome session.`)}let z=GQ(),$=v(z,"utf8").trim().split(`
-`);return`ws://localhost:${$[0]}${$[1]}`}var A=(Q)=>new Promise((z)=>setTimeout(z,Q));function S(){if(u()==="win32")return[];try{return jQ(j).filter((Q)=>Q.endsWith(".sock")).map((Q)=>({targetId:Q.slice(0,-5),socketPath:k(j,Q)}))}catch{return[]}}function _(Q,z,$="target",V=""){let X=Q.toUpperCase(),W=z.filter((Z)=>Z.toUpperCase().startsWith(X));if(W.length===0){let Z=V?` ${V}`:"";throw Error(`No ${$} matching prefix "${Q}".${Z}`)}if(W.length>1)throw Error(`Ambiguous prefix "${Q}" — matches ${W.length} ${$}s. Use more characters.`);return W[0]}function AQ(Q){if(Q.length===0)return r;let z=Math.max(...Q.map(($)=>$.length));for(let $=r;$<=z;$++)if(new Set(Q.map((X)=>X.slice(0,$).toUpperCase())).size===Q.length)return $;return z}class h{#Q;#X=0;#$=new Map;#V=new Map;#z=[];async connect(Q){return new Promise((z,$)=>{this.#Q=new WebSocket(Q),this.#Q.onopen=()=>z(),this.#Q.onerror=(V)=>$(Error(`WebSocket error: ${V.message||V.type}`)),this.#Q.onclose=()=>this.#z.forEach((V)=>V()),this.#Q.onmessage=(V)=>{let X=JSON.parse(V.data);if(X.id&&this.#$.has(X.id)){let{resolve:W,reject:Z}=this.#$.get(X.id);if(this.#$.delete(X.id),X.error)Z(Error(X.error.message));else W(X.result)}else if(X.method&&this.#V.has(X.method))for(let W of[...this.#V.get(X.method)])W(X.params||{},X)}})}send(Q,z={},$){let V=++this.#X;return new Promise((X,W)=>{this.#$.set(V,{resolve:X,reject:W});let Z={id:V,method:Q,params:z};if($)Z.sessionId=$;this.#Q.send(JSON.stringify(Z)),setTimeout(()=>{if(this.#$.has(V))this.#$.delete(V),W(Error(`Timeout: ${Q}`))},c)})}onEvent(Q,z){if(!this.#V.has(Q))this.#V.set(Q,new Set);let $=this.#V.get(Q);return $.add(z),()=>{if($.delete(z),$.size===0)this.#V.delete(Q)}}waitForEvent(Q,z=c){let $=!1,V,X;return{promise:new Promise((Z,q)=>{V=this.onEvent(Q,(H)=>{if($)return;$=!0,clearTimeout(X),V(),Z(H)}),X=setTimeout(()=>{if($)return;$=!0,V(),q(Error(`Timeout waiting for event: ${Q}`))},z)}),cancel(){if($)return;$=!0,clearTimeout(X),V?.()}}}onClose(Q){this.#z.push(Q)}close(){this.#Q.close()}}async function x(Q){let{targetInfos:z}=await Q.send("Target.getTargets");return z.filter(($)=>$.type==="page"&&(!$.url.startsWith("chrome://")||$.url==="chrome://newtab/"))}function zQ(Q){let z=AQ(Q.map(($)=>$.targetId));return Q.map(($)=>{let V=$.targetId.slice(0,z).padEnd(z),X=$.title.substring(0,54).padEnd(54);return`${V}  ${X}  ${$.url}`}).join(`
-`)}function yQ(Q,z=!1){let $=Q.role?.value||"",V=Q.name?.value??"",X=Q.value?.value;if(z&&$==="InlineTextBox")return!1;return $!=="none"&&$!=="generic"&&!(V===""&&(X===""||X==null))}function NQ(Q,z){let $=Q.role?.value||"",V=Q.name?.value??"",X=Q.value?.value,Z=`${"  ".repeat(Math.min(z,10))}[${$}]`;if(V!=="")Z+=` ${V}`;if(!(X===""||X==null))Z+=` = ${JSON.stringify(X)}`;return Z}function FQ(Q,z,$){let V=[],X=new Set;for(let W of Q.childIds||[]){let Z=z.get(W);if(Z&&!X.has(Z.nodeId))X.add(Z.nodeId),V.push(Z)}for(let W of $.get(Q.nodeId)||[])if(!X.has(W.nodeId))X.add(W.nodeId),V.push(W);return V}async function TQ(Q,z,$=!1){let{nodes:V}=await Q.send("Accessibility.getFullAXTree",{},z),X=new Map(V.map((K)=>[K.nodeId,K])),W=new Map;for(let K of V){if(!K.parentId)continue;if(!W.has(K.parentId))W.set(K.parentId,[]);W.get(K.parentId).push(K)}let Z=[],q=new Set;function H(K,B){if(!K||q.has(K.nodeId))return;if(q.add(K.nodeId),yQ(K,$))Z.push(NQ(K,B));for(let J of FQ(K,X,W))H(J,B+1)}let b=V.filter((K)=>!K.parentId||!X.has(K.parentId));for(let K of b)H(K,0);for(let K of V)H(K,0);return Z.join(`
-`)}var L=new Map;async function n(Q,z){let $=[],V=Q.onEvent("Runtime.executionContextCreated",(q)=>{if(q?.context)$.push(q.context)});await Q.send("Runtime.enable",{},z),await A(100),V(),await Q.send("Runtime.disable",{},z).catch(()=>{});let X=null;try{X=(await Q.send("Page.getFrameTree",{},z))?.frameTree?.frame?.id??null}catch{}let W=$.filter((q)=>q.auxData?.isDefault&&q.auxData?.type==="default");return(X&&W.find((q)=>q.auxData?.frameId===X)||W[0]||null)?.id??null}async function w(Q,z,$){let V=L.get(z);if(V==null){if(V=await n(Q,z),V==null)throw Error("Failed to capture main execution context — is the page loaded?");L.set(z,V)}async function X(W){let Z=await Q.send("Runtime.evaluate",{expression:$,contextId:W,returnByValue:!0,awaitPromise:!0},z);if(Z.exceptionDetails)throw Error(Z.exceptionDetails.text||Z.exceptionDetails.exception?.description);let q=Z.result.value;return typeof q==="object"?JSON.stringify(q,null,2):String(q??"")}try{return await X(V)}catch(W){if(L.delete(z),V=await n(Q,z),V==null)throw Error("Failed to re-capture execution context after navigation");return L.set(z,V),X(V)}}async function CQ(Q,z,$){let V=1;try{let q=await Q.send("Page.getLayoutMetrics",{},z);V=q.visualViewport?.clientWidth?q.cssVisualViewport?.clientWidth?Math.round(q.visualViewport.clientWidth/q.cssVisualViewport.clientWidth*100)/100:1:1;let{deviceScaleFactor:H}=await Q.send("Emulation.getDeviceMetricsOverride",{},z).catch(()=>({}));if(H)V=H}catch{}if(V===1)try{let q=await w(Q,z,"window.devicePixelRatio"),H=Number.parseFloat(q);if(H>0)V=H}catch{}let{data:X}=await Q.send("Page.captureScreenshot",{format:"png"},z),W=$||k(kQ(),"screenshot.png");s(W,Buffer.from(X,"base64"));let Z=[W];if(Z.push(`Screenshot saved. Device pixel ratio (DPR): ${V}`),Z.push("Coordinate mapping:"),Z.push(`  Screenshot pixels → CSS pixels (for CDP Input events): divide by ${V}`),Z.push(`  e.g. screenshot point (${Math.round(100*V)}, ${Math.round(200*V)}) → CSS (100, 200) → use clickxy <target> 100 200`),V!==1)Z.push(`  On this ${V}x display: CSS px = screenshot px / ${V} ≈ screenshot px × ${Math.round(100/V)/100}`);return Z.join(`
-`)}async function RQ(Q,z,$){let V=$?`document.querySelector(${JSON.stringify($)})?.outerHTML || 'Element not found'`:"document.documentElement.outerHTML";return w(Q,z,V)}async function PQ(Q,z,$=QQ){let V=Date.now()+$,X="",W;while(Date.now()<V){try{let Z=await w(Q,z,"document.readyState");if(X=Z,Z==="complete")return}catch(Z){W=Z}await A(200)}if(X)throw Error(`Timed out waiting for navigation to finish (last readyState: ${X})`);if(W)throw Error(`Timed out waiting for navigation to finish (${W.message})`);throw Error("Timed out waiting for navigation to finish")}async function DQ(Q,z,$){await Q.send("Page.enable",{},z);let V=Q.waitForEvent("Page.loadEventFired",QQ),X=await Q.send("Page.navigate",{url:$},z);if(X.errorText)throw V.cancel(),Error(X.errorText);L.delete(z);let W=!1;if(X.loaderId)try{await V.promise,W=!0}catch{}else V.cancel();if(!W)await PQ(Q,z,5000);return`Navigated to ${$}`}async function fQ(Q,z){let $=await w(Q,z,`JSON.stringify(performance.getEntriesByType('resource').map(e => ({
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { nodeRuntimeCommand } from "../src/utils/node-runtime.mjs";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import net from "node:net";
+import { homedir, platform, tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  GREEDY_CDP_SOCKET_DIR,
+  PAGES_CACHE
+} from "../src/search/constants.mjs";
+const TIMEOUT = 90000;
+const NAVIGATION_TIMEOUT = 30000;
+const IDLE_TIMEOUT = 20 * 60 * 1000;
+const DAEMON_CONNECT_RETRIES = 20;
+const DAEMON_CONNECT_DELAY = 300;
+const MIN_TARGET_PREFIX_LEN = 8;
+const SOCKET_SCOPE = createHash("sha256").update(GREEDY_CDP_SOCKET_DIR).digest("hex").slice(0, 12);
+function sockPath(targetId) {
+  if (platform() === "win32")
+    return `\\\\.\\pipe\\dm-cdp-${SOCKET_SCOPE}-${targetId}`;
+  mkdirSync(GREEDY_CDP_SOCKET_DIR, { recursive: true });
+  return join(GREEDY_CDP_SOCKET_DIR, `${targetId}.sock`);
+}
+function getDevToolsActivePortPath() {
+  const os = platform();
+  if (os === "win32")
+    return join(homedir(), "AppData", "Local", "Google", "Chrome", "User Data", "DevToolsActivePort");
+  if (os === "darwin")
+    return join(homedir(), "Library", "Application Support", "Google", "Chrome", "DevToolsActivePort");
+  return join(homedir(), ".config", "google-chrome", "DevToolsActivePort");
+}
+function getWsUrl() {
+  const profileDir = process.env.CDP_PROFILE_DIR;
+  if (profileDir) {
+    const p = `${profileDir.replaceAll("\\", "/")}/DevToolsActivePort`;
+    if (existsSync(p)) {
+      const lines = readFileSync(p, "utf8").trim().split(`
+`);
+      return `ws://localhost:${lines[0]}${lines[1]}`;
+    }
+    throw new Error(`GreedySearch DevToolsActivePort not found at ${p}. Refusing to fall back to the main Chrome session.`);
+  }
+  const portFile = getDevToolsActivePortPath();
+  const lines = readFileSync(portFile, "utf8").trim().split(`
+`);
+  return `ws://localhost:${lines[0]}${lines[1]}`;
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function listDaemonSockets() {
+  if (platform() === "win32")
+    return [];
+  try {
+    return readdirSync(GREEDY_CDP_SOCKET_DIR).filter((f) => f.endsWith(".sock")).map((f) => ({
+      targetId: f.slice(0, -5),
+      socketPath: join(GREEDY_CDP_SOCKET_DIR, f)
+    }));
+  } catch {
+    return [];
+  }
+}
+function resolvePrefix(prefix, candidates, noun = "target", missingHint = "") {
+  const upper = prefix.toUpperCase();
+  const matches = candidates.filter((candidate) => candidate.toUpperCase().startsWith(upper));
+  if (matches.length === 0) {
+    const hint = missingHint ? ` ${missingHint}` : "";
+    throw new Error(`No ${noun} matching prefix "${prefix}".${hint}`);
+  }
+  if (matches.length > 1) {
+    throw new Error(`Ambiguous prefix "${prefix}" — matches ${matches.length} ${noun}s. Use more characters.`);
+  }
+  return matches[0];
+}
+function getDisplayPrefixLength(targetIds) {
+  if (targetIds.length === 0)
+    return MIN_TARGET_PREFIX_LEN;
+  const maxLen = Math.max(...targetIds.map((id) => id.length));
+  for (let len = MIN_TARGET_PREFIX_LEN;len <= maxLen; len++) {
+    const prefixes = new Set(targetIds.map((id) => id.slice(0, len).toUpperCase()));
+    if (prefixes.size === targetIds.length)
+      return len;
+  }
+  return maxLen;
+}
+
+class CDP {
+  #ws;
+  #id = 0;
+  #pending = new Map;
+  #eventHandlers = new Map;
+  #closeHandlers = [];
+  async connect(wsUrl) {
+    return new Promise((res, rej) => {
+      this.#ws = new WebSocket(wsUrl);
+      this.#ws.onopen = () => res();
+      this.#ws.onerror = (e) => rej(new Error(`WebSocket error: ${e.message || e.type}`));
+      this.#ws.onclose = () => this.#closeHandlers.forEach((h) => h());
+      this.#ws.onmessage = (ev) => {
+        const msg = JSON.parse(ev.data);
+        if (msg.id && this.#pending.has(msg.id)) {
+          const { resolve, reject } = this.#pending.get(msg.id);
+          this.#pending.delete(msg.id);
+          if (msg.error)
+            reject(new Error(msg.error.message));
+          else
+            resolve(msg.result);
+        } else if (msg.method && this.#eventHandlers.has(msg.method)) {
+          for (const handler of [...this.#eventHandlers.get(msg.method)]) {
+            handler(msg.params || {}, msg);
+          }
+        }
+      };
+    });
+  }
+  send(method, params = {}, sessionId) {
+    const id = ++this.#id;
+    return new Promise((resolve, reject) => {
+      this.#pending.set(id, { resolve, reject });
+      const msg = { id, method, params };
+      if (sessionId)
+        msg.sessionId = sessionId;
+      this.#ws.send(JSON.stringify(msg));
+      setTimeout(() => {
+        if (this.#pending.has(id)) {
+          this.#pending.delete(id);
+          reject(new Error(`Timeout: ${method}`));
+        }
+      }, TIMEOUT);
+    });
+  }
+  onEvent(method, handler) {
+    if (!this.#eventHandlers.has(method))
+      this.#eventHandlers.set(method, new Set);
+    const handlers = this.#eventHandlers.get(method);
+    handlers.add(handler);
+    return () => {
+      handlers.delete(handler);
+      if (handlers.size === 0)
+        this.#eventHandlers.delete(method);
+    };
+  }
+  waitForEvent(method, timeout = TIMEOUT) {
+    let settled = false;
+    let off;
+    let timer;
+    const promise = new Promise((resolve, reject) => {
+      off = this.onEvent(method, (params) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        off();
+        resolve(params);
+      });
+      timer = setTimeout(() => {
+        if (settled)
+          return;
+        settled = true;
+        off();
+        reject(new Error(`Timeout waiting for event: ${method}`));
+      }, timeout);
+    });
+    return {
+      promise,
+      cancel() {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        off?.();
+      }
+    };
+  }
+  onClose(handler) {
+    this.#closeHandlers.push(handler);
+  }
+  close() {
+    this.#ws.close();
+  }
+}
+async function getPages(cdp) {
+  const { targetInfos } = await cdp.send("Target.getTargets");
+  return targetInfos.filter((t) => t.type === "page" && (!t.url.startsWith("chrome://") || t.url === "chrome://newtab/"));
+}
+function formatPageList(pages) {
+  const prefixLen = getDisplayPrefixLength(pages.map((p) => p.targetId));
+  return pages.map((p) => {
+    const id = p.targetId.slice(0, prefixLen).padEnd(prefixLen);
+    const title = p.title.substring(0, 54).padEnd(54);
+    return `${id}  ${title}  ${p.url}`;
+  }).join(`
+`);
+}
+function shouldShowAxNode(node, compact = false) {
+  const role = node.role?.value || "";
+  const name = node.name?.value ?? "";
+  const value = node.value?.value;
+  if (compact && role === "InlineTextBox")
+    return false;
+  return role !== "none" && role !== "generic" && !(name === "" && (value === "" || value == null));
+}
+function formatAxNode(node, depth) {
+  const role = node.role?.value || "";
+  const name = node.name?.value ?? "";
+  const value = node.value?.value;
+  const indent = "  ".repeat(Math.min(depth, 10));
+  let line = `${indent}[${role}]`;
+  if (name !== "")
+    line += ` ${name}`;
+  if (!(value === "" || value == null))
+    line += ` = ${JSON.stringify(value)}`;
+  return line;
+}
+function orderedAxChildren(node, nodesById, childrenByParent) {
+  const children = [];
+  const seen = new Set;
+  for (const childId of node.childIds || []) {
+    const child = nodesById.get(childId);
+    if (child && !seen.has(child.nodeId)) {
+      seen.add(child.nodeId);
+      children.push(child);
+    }
+  }
+  for (const child of childrenByParent.get(node.nodeId) || []) {
+    if (!seen.has(child.nodeId)) {
+      seen.add(child.nodeId);
+      children.push(child);
+    }
+  }
+  return children;
+}
+async function snapshotStr(cdp, sid, compact = false) {
+  const { nodes } = await cdp.send("Accessibility.getFullAXTree", {}, sid);
+  const nodesById = new Map(nodes.map((node) => [node.nodeId, node]));
+  const childrenByParent = new Map;
+  for (const node of nodes) {
+    if (!node.parentId)
+      continue;
+    if (!childrenByParent.has(node.parentId))
+      childrenByParent.set(node.parentId, []);
+    childrenByParent.get(node.parentId).push(node);
+  }
+  const lines = [];
+  const visited = new Set;
+  function visit(node, depth) {
+    if (!node || visited.has(node.nodeId))
+      return;
+    visited.add(node.nodeId);
+    if (shouldShowAxNode(node, compact))
+      lines.push(formatAxNode(node, depth));
+    for (const child of orderedAxChildren(node, nodesById, childrenByParent)) {
+      visit(child, depth + 1);
+    }
+  }
+  const roots = nodes.filter((node) => !node.parentId || !nodesById.has(node.parentId));
+  for (const root of roots)
+    visit(root, 0);
+  for (const node of nodes)
+    visit(node, 0);
+  return lines.join(`
+`);
+}
+const _mainCtx = new Map;
+async function captureMainContext(cdp, sid) {
+  const contexts = [];
+  const off = cdp.onEvent("Runtime.executionContextCreated", (params) => {
+    if (params?.context)
+      contexts.push(params.context);
+  });
+  await cdp.send("Runtime.enable", {}, sid);
+  await sleep(100);
+  off();
+  await cdp.send("Runtime.disable", {}, sid).catch(() => {});
+  let rootFrameId = null;
+  try {
+    const ft = await cdp.send("Page.getFrameTree", {}, sid);
+    rootFrameId = ft?.frameTree?.frame?.id ?? null;
+  } catch {}
+  const defaults = contexts.filter((ctx) => ctx.auxData?.isDefault && ctx.auxData?.type === "default");
+  const main = rootFrameId && defaults.find((ctx) => ctx.auxData?.frameId === rootFrameId) || defaults[0] || null;
+  return main?.id ?? null;
+}
+async function evalStr(cdp, sid, expression) {
+  let contextId = _mainCtx.get(sid);
+  if (contextId == null) {
+    contextId = await captureMainContext(cdp, sid);
+    if (contextId == null) {
+      throw new Error("Failed to capture main execution context — is the page loaded?");
+    }
+    _mainCtx.set(sid, contextId);
+  }
+  async function _evalWith(cid) {
+    const result = await cdp.send("Runtime.evaluate", {
+      expression,
+      contextId: cid,
+      returnByValue: true,
+      awaitPromise: true
+    }, sid);
+    if (result.exceptionDetails) {
+      throw new Error(result.exceptionDetails.text || result.exceptionDetails.exception?.description);
+    }
+    const val = result.result.value;
+    return typeof val === "object" ? JSON.stringify(val, null, 2) : String(val ?? "");
+  }
+  try {
+    return await _evalWith(contextId);
+  } catch (_e) {
+    _mainCtx.delete(sid);
+    contextId = await captureMainContext(cdp, sid);
+    if (contextId == null) {
+      throw new Error("Failed to re-capture execution context after navigation");
+    }
+    _mainCtx.set(sid, contextId);
+    return _evalWith(contextId);
+  }
+}
+async function shotStr(cdp, sid, filePath) {
+  let dpr = 1;
+  try {
+    const metrics = await cdp.send("Page.getLayoutMetrics", {}, sid);
+    dpr = metrics.visualViewport?.clientWidth ? metrics.cssVisualViewport?.clientWidth ? Math.round(metrics.visualViewport.clientWidth / metrics.cssVisualViewport.clientWidth * 100) / 100 : 1 : 1;
+    const { deviceScaleFactor } = await cdp.send("Emulation.getDeviceMetricsOverride", {}, sid).catch(() => ({}));
+    if (deviceScaleFactor)
+      dpr = deviceScaleFactor;
+  } catch {}
+  if (dpr === 1) {
+    try {
+      const raw = await evalStr(cdp, sid, "window.devicePixelRatio");
+      const parsed = Number.parseFloat(raw);
+      if (parsed > 0)
+        dpr = parsed;
+    } catch {}
+  }
+  const { data } = await cdp.send("Page.captureScreenshot", { format: "png" }, sid);
+  const out = filePath || join(tmpdir(), "screenshot.png");
+  writeFileSync(out, Buffer.from(data, "base64"));
+  const lines = [out];
+  lines.push(`Screenshot saved. Device pixel ratio (DPR): ${dpr}`);
+  lines.push(`Coordinate mapping:`);
+  lines.push(`  Screenshot pixels → CSS pixels (for CDP Input events): divide by ${dpr}`);
+  lines.push(`  e.g. screenshot point (${Math.round(100 * dpr)}, ${Math.round(200 * dpr)}) → CSS (100, 200) → use clickxy <target> 100 200`);
+  if (dpr !== 1) {
+    lines.push(`  On this ${dpr}x display: CSS px = screenshot px / ${dpr} ≈ screenshot px × ${Math.round(100 / dpr) / 100}`);
+  }
+  return lines.join(`
+`);
+}
+async function htmlStr(cdp, sid, selector) {
+  const expr = selector ? `document.querySelector(${JSON.stringify(selector)})?.outerHTML || 'Element not found'` : `document.documentElement.outerHTML`;
+  return evalStr(cdp, sid, expr);
+}
+async function waitForDocumentReady(cdp, sid, timeoutMs = NAVIGATION_TIMEOUT) {
+  const deadline = Date.now() + timeoutMs;
+  let lastState = "";
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      const state = await evalStr(cdp, sid, "document.readyState");
+      lastState = state;
+      if (state === "complete")
+        return;
+    } catch (e) {
+      lastError = e;
+    }
+    await sleep(200);
+  }
+  if (lastState) {
+    throw new Error(`Timed out waiting for navigation to finish (last readyState: ${lastState})`);
+  }
+  if (lastError) {
+    throw new Error(`Timed out waiting for navigation to finish (${lastError.message})`);
+  }
+  throw new Error("Timed out waiting for navigation to finish");
+}
+async function navStr(cdp, sid, url) {
+  await cdp.send("Page.enable", {}, sid);
+  const loadEvent = cdp.waitForEvent("Page.loadEventFired", NAVIGATION_TIMEOUT);
+  const result = await cdp.send("Page.navigate", { url }, sid);
+  if (result.errorText) {
+    loadEvent.cancel();
+    throw new Error(result.errorText);
+  }
+  _mainCtx.delete(sid);
+  let loadFired = false;
+  if (result.loaderId) {
+    try {
+      await loadEvent.promise;
+      loadFired = true;
+    } catch {}
+  } else {
+    loadEvent.cancel();
+  }
+  if (!loadFired) {
+    await waitForDocumentReady(cdp, sid, 5000);
+  }
+  return `Navigated to ${url}`;
+}
+async function netStr(cdp, sid) {
+  const raw = await evalStr(cdp, sid, `JSON.stringify(performance.getEntriesByType('resource').map(e => ({
     name: e.name.substring(0, 120), type: e.initiatorType,
     duration: Math.round(e.duration), size: e.transferSize
-  })))`);return JSON.parse($).map((V)=>`${String(V.duration).padStart(5)}ms  ${String(V.size||"?").padStart(8)}B  ${V.type.padEnd(8)}  ${V.name}`).join(`
-`)}async function vQ(Q,z,$){if(!$)throw Error("CSS selector required");let V=`
+  })))`);
+  return JSON.parse(raw).map((e) => `${String(e.duration).padStart(5)}ms  ${String(e.size || "?").padStart(8)}B  ${e.type.padEnd(8)}  ${e.name}`).join(`
+`);
+}
+async function clickStr(cdp, sid, selector) {
+  if (!selector)
+    throw new Error("CSS selector required");
+  const expr = `
     (function() {
-      const el = document.querySelector(${JSON.stringify($)});
-      if (!el) return { ok: false, error: 'Element not found: ' + ${JSON.stringify($)} };
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) return { ok: false, error: 'Element not found: ' + ${JSON.stringify(selector)} };
       el.scrollIntoView({ block: 'center' });
       el.click();
       return { ok: true, tag: el.tagName, text: el.textContent.trim().substring(0, 80) };
     })()
-  `,X=await w(Q,z,V),W=JSON.parse(X);if(!W.ok)throw Error(W.error);return`Clicked <${W.tag}> "${W.text}"`}async function _Q(Q,z,$,V){let X=Number.parseFloat($),W=Number.parseFloat(V);if(Number.isNaN(X)||Number.isNaN(W))throw Error("x and y must be numbers (CSS pixels)");let Z={x:X,y:W,button:"left",clickCount:1,modifiers:0};return await Q.send("Input.dispatchMouseEvent",{...Z,type:"mouseMoved"},z),await Q.send("Input.dispatchMouseEvent",{...Z,type:"mousePressed"},z),await A(50),await Q.send("Input.dispatchMouseEvent",{...Z,type:"mouseReleased"},z),`Clicked at CSS (${X}, ${W})`}async function xQ(Q,z,$){if($==null||$==="")throw Error("text required");return await Q.send("Input.insertText",{text:$},z),`Typed ${$.length} characters`}async function uQ(Q,z,$,V=1500){if(!$)throw Error("CSS selector required");V=Math.min(Math.max(Number.parseInt(V,10)||1500,100),30000);let X=0,W=Date.now()+300000;while(Date.now()<W){if(await w(Q,z,`!!document.querySelector(${JSON.stringify($)})`)!=="true")break;let q=`
+  `;
+  const result = await evalStr(cdp, sid, expr);
+  const r = JSON.parse(result);
+  if (!r.ok)
+    throw new Error(r.error);
+  return `Clicked <${r.tag}> "${r.text}"`;
+}
+async function clickXyStr(cdp, sid, x, y) {
+  const cx = Number.parseFloat(x);
+  const cy = Number.parseFloat(y);
+  if (Number.isNaN(cx) || Number.isNaN(cy))
+    throw new Error("x and y must be numbers (CSS pixels)");
+  const base = { x: cx, y: cy, button: "left", clickCount: 1, modifiers: 0 };
+  await cdp.send("Input.dispatchMouseEvent", { ...base, type: "mouseMoved" }, sid);
+  await cdp.send("Input.dispatchMouseEvent", { ...base, type: "mousePressed" }, sid);
+  await sleep(50);
+  await cdp.send("Input.dispatchMouseEvent", { ...base, type: "mouseReleased" }, sid);
+  return `Clicked at CSS (${cx}, ${cy})`;
+}
+async function typeStr(cdp, sid, text) {
+  if (text == null || text === "")
+    throw new Error("text required");
+  await cdp.send("Input.insertText", { text }, sid);
+  return `Typed ${text.length} characters`;
+}
+async function loadAllStr(cdp, sid, selector, intervalMs = 1500) {
+  if (!selector)
+    throw new Error("CSS selector required");
+  intervalMs = Math.min(Math.max(Number.parseInt(intervalMs, 10) || 1500, 100), 30000);
+  let clicks = 0;
+  const deadline = Date.now() + 5 * 60 * 1000;
+  while (Date.now() < deadline) {
+    const exists = await evalStr(cdp, sid, `!!document.querySelector(${JSON.stringify(selector)})`);
+    if (exists !== "true")
+      break;
+    const clickExpr = `
       (function() {
-        const el = document.querySelector(${JSON.stringify($)});
+        const el = document.querySelector(${JSON.stringify(selector)});
         if (!el) return false;
         el.scrollIntoView({ block: 'center' });
         el.click();
         return true;
       })()
-    `;if(await w(Q,z,q)!=="true")break;X++,await A(V)}return`Clicked "${$}" ${X} time(s) until it disappeared`}async function SQ(Q,z,$,V){if(!$)throw Error('CDP method required (e.g. "DOM.getDocument")');let X={};if(V)try{X=JSON.parse(V)}catch{throw Error(`Invalid JSON params: ${V}`)}let W=await Q.send($,X,z);return JSON.stringify(W,null,2)}async function hQ(Q,z,$){if(!z)throw Error("Browser CDP method required");let V={};if($)try{V=JSON.parse($)}catch{throw Error(`Invalid JSON params: ${$}`)}let X=await Q.send(z,V);return JSON.stringify(X,null,2)}async function EQ(Q){let z=$Q(Q),$=new h;try{await $.connect(VQ())}catch(K){process.stderr.write(`Daemon: cannot connect to Chrome: ${K.message}
-`),process.exit(1)}let V;try{V=(await $.send("Target.attachToTarget",{targetId:Q,flatten:!0})).sessionId}catch(K){process.stderr.write(`Daemon: attach failed: ${K.message}
-`),$.close(),process.exit(1)}let X=!0;function W(){if(!X)return;X=!1,b.close();try{O(z)}catch{}$.close(),process.exit(0)}$.onEvent("Target.targetDestroyed",(K)=>{if(K.targetId===Q)W()}),$.onEvent("Target.detachedFromTarget",(K)=>{if(K.sessionId===V)W()}),$.onClose(()=>W()),process.on("SIGTERM",W),process.on("SIGINT",W);let Z=setTimeout(W,a);function q(){clearTimeout(Z),Z=setTimeout(W,a)}async function H({cmd:K,args:B}){q();try{let J;switch(K){case"list":{let Y=await x($);J=zQ(Y);break}case"list_raw":{let Y=await x($);J=JSON.stringify(Y);break}case"snap":case"snapshot":J=await TQ($,V,!0);break;case"eval":J=await w($,V,B[0]);break;case"shot":case"screenshot":J=await CQ($,V,B[0]);break;case"html":J=await RQ($,V,B[0]);break;case"nav":case"navigate":J=await DQ($,V,B[0]);break;case"net":case"network":J=await fQ($,V);break;case"click":J=await vQ($,V,B[0]);break;case"clickxy":J=await _Q($,V,B[0],B[1]);break;case"type":J=await xQ($,V,B[0]);break;case"loadall":J=await uQ($,V,B[0],B[1]?Number.parseInt(B[1],10):1500);break;case"evalraw":J=await SQ($,V,B[0],B[1]);break;case"browse":case"browserraw":J=await hQ($,B[0],B[1]);break;case"stop":return{ok:!0,result:"",stopAfter:!0};default:return{ok:!1,error:`Unknown command: ${K}`}}return{ok:!0,result:J??""}}catch(J){return{ok:!1,error:J.message}}}let b=e.createServer((K)=>{let B="";K.on("data",(J)=>{B+=J.toString();let Y=B.split(`
-`);B=Y.pop();for(let E of Y){if(!E.trim())continue;let T;try{T=JSON.parse(E)}catch{K.write(`${JSON.stringify({ok:!1,error:"Invalid JSON request",id:null})}
-`);continue}H(T).then((I)=>{let g=`${JSON.stringify({...I,id:T.id})}
-`;if(I.stopAfter)K.end(g,W);else K.write(g)})}})});try{O(z)}catch{}b.listen(z)}function G(Q){return new Promise((z,$)=>{let V=e.connect(Q);V.on("connect",()=>z(V)),V.on("error",$)})}async function IQ(Q){let z=$Q(Q);try{return await G(z)}catch{}try{O(z)}catch{}MQ(m(),[process.argv[1],"_daemon",Q],{detached:!0,stdio:"ignore"}).unref();let V=[50,100,200],X=Date.now()+LQ*o,W=0;while(Date.now()<X){try{return await G(z)}catch{}let Z=V[W]??o;W++,await A(Z)}throw Error("Daemon failed to start — did you click Allow in Chrome?")}function F(Q,z){return new Promise(($,V)=>{let X="",W=!1,Z=()=>{Q.off("data",q),Q.off("error",H),Q.off("end",b),Q.off("close",K)},q=(B)=>{X+=B.toString();let J=X.indexOf(`
-`);if(J===-1)return;W=!0,Z();try{$(JSON.parse(X.slice(0,J)))}catch(Y){V(Error(`Invalid JSON response from daemon: ${Y.message}`))}Q.end()},H=(B)=>{if(W)return;W=!0,Z(),V(B)},b=()=>{if(W)return;W=!0,Z(),V(Error("Connection closed before response"))},K=()=>{if(W)return;W=!0,Z(),V(Error("Connection closed before response"))};Q.on("data",q),Q.on("error",H),Q.on("end",b),Q.on("close",K),z.id=1,Q.write(`${JSON.stringify(z)}
-`)})}function gQ(){return S()[0]?.socketPath||null}async function mQ(Q){let z=S();if(Q){let $=_(Q,z.map((X)=>X.targetId),"daemon"),V=z.find((X)=>X.targetId===$);try{let X=await G(V.socketPath);await F(X,{cmd:"stop"})}catch{try{O(V.socketPath)}catch{}}return}for(let $ of z)try{let V=await G($.socketPath);await F(V,{cmd:"stop"})}catch{try{O($.socketPath)}catch{}}}var t=`cdp - lightweight Chrome DevTools Protocol CLI (no Puppeteer)
+    `;
+    const clicked = await evalStr(cdp, sid, clickExpr);
+    if (clicked !== "true")
+      break;
+    clicks++;
+    await sleep(intervalMs);
+  }
+  return `Clicked "${selector}" ${clicks} time(s) until it disappeared`;
+}
+async function evalRawStr(cdp, sid, method, paramsJson) {
+  if (!method)
+    throw new Error('CDP method required (e.g. "DOM.getDocument")');
+  let params = {};
+  if (paramsJson) {
+    try {
+      params = JSON.parse(paramsJson);
+    } catch {
+      throw new Error(`Invalid JSON params: ${paramsJson}`);
+    }
+  }
+  const result = await cdp.send(method, params, sid);
+  return JSON.stringify(result, null, 2);
+}
+async function browserRawStr(cdp, method, paramsJson) {
+  if (!method)
+    throw new Error("Browser CDP method required");
+  let params = {};
+  if (paramsJson) {
+    try {
+      params = JSON.parse(paramsJson);
+    } catch {
+      throw new Error(`Invalid JSON params: ${paramsJson}`);
+    }
+  }
+  const result = await cdp.send(method, params);
+  return JSON.stringify(result, null, 2);
+}
+async function runDaemon(targetId) {
+  const sp = sockPath(targetId);
+  const cdp = new CDP;
+  try {
+    await cdp.connect(getWsUrl());
+  } catch (e) {
+    process.stderr.write(`Daemon: cannot connect to Chrome: ${e.message}
+`);
+    process.exit(1);
+  }
+  let sessionId;
+  try {
+    const res = await cdp.send("Target.attachToTarget", {
+      targetId,
+      flatten: true
+    });
+    sessionId = res.sessionId;
+  } catch (e) {
+    process.stderr.write(`Daemon: attach failed: ${e.message}
+`);
+    cdp.close();
+    process.exit(1);
+  }
+  let alive = true;
+  function shutdown() {
+    if (!alive)
+      return;
+    alive = false;
+    server.close();
+    try {
+      unlinkSync(sp);
+    } catch {}
+    cdp.close();
+    process.exit(0);
+  }
+  cdp.onEvent("Target.targetDestroyed", (params) => {
+    if (params.targetId === targetId)
+      shutdown();
+  });
+  cdp.onEvent("Target.detachedFromTarget", (params) => {
+    if (params.sessionId === sessionId)
+      shutdown();
+  });
+  cdp.onClose(() => shutdown());
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+  let idleTimer = setTimeout(shutdown, IDLE_TIMEOUT);
+  function resetIdle() {
+    clearTimeout(idleTimer);
+    idleTimer = setTimeout(shutdown, IDLE_TIMEOUT);
+  }
+  async function handleCommand({ cmd, args }) {
+    resetIdle();
+    try {
+      let result;
+      switch (cmd) {
+        case "list": {
+          const pages = await getPages(cdp);
+          result = formatPageList(pages);
+          break;
+        }
+        case "list_raw": {
+          const pages = await getPages(cdp);
+          result = JSON.stringify(pages);
+          break;
+        }
+        case "snap":
+        case "snapshot":
+          result = await snapshotStr(cdp, sessionId, true);
+          break;
+        case "eval":
+          result = await evalStr(cdp, sessionId, args[0]);
+          break;
+        case "shot":
+        case "screenshot":
+          result = await shotStr(cdp, sessionId, args[0]);
+          break;
+        case "html":
+          result = await htmlStr(cdp, sessionId, args[0]);
+          break;
+        case "nav":
+        case "navigate":
+          result = await navStr(cdp, sessionId, args[0]);
+          break;
+        case "net":
+        case "network":
+          result = await netStr(cdp, sessionId);
+          break;
+        case "click":
+          result = await clickStr(cdp, sessionId, args[0]);
+          break;
+        case "clickxy":
+          result = await clickXyStr(cdp, sessionId, args[0], args[1]);
+          break;
+        case "type":
+          result = await typeStr(cdp, sessionId, args[0]);
+          break;
+        case "loadall":
+          result = await loadAllStr(cdp, sessionId, args[0], args[1] ? Number.parseInt(args[1], 10) : 1500);
+          break;
+        case "evalraw":
+          result = await evalRawStr(cdp, sessionId, args[0], args[1]);
+          break;
+        case "browse":
+        case "browserraw":
+          result = await browserRawStr(cdp, args[0], args[1]);
+          break;
+        case "stop":
+          return { ok: true, result: "", stopAfter: true };
+        default:
+          return { ok: false, error: `Unknown command: ${cmd}` };
+      }
+      return { ok: true, result: result ?? "" };
+    } catch (e) {
+      return { ok: false, error: e.message };
+    }
+  }
+  const server = net.createServer((conn) => {
+    let buf = "";
+    conn.on("data", (chunk) => {
+      buf += chunk.toString();
+      const lines = buf.split(`
+`);
+      buf = lines.pop();
+      for (const line of lines) {
+        if (!line.trim())
+          continue;
+        let req;
+        try {
+          req = JSON.parse(line);
+        } catch {
+          conn.write(`${JSON.stringify({ ok: false, error: "Invalid JSON request", id: null })}
+`);
+          continue;
+        }
+        handleCommand(req).then((res) => {
+          const payload = `${JSON.stringify({ ...res, id: req.id })}
+`;
+          if (res.stopAfter)
+            conn.end(payload, shutdown);
+          else
+            conn.write(payload);
+        });
+      }
+    });
+  });
+  try {
+    unlinkSync(sp);
+  } catch {}
+  server.listen(sp);
+}
+function connectToSocket(sp) {
+  return new Promise((resolve, reject) => {
+    const conn = net.connect(sp);
+    conn.on("connect", () => resolve(conn));
+    conn.on("error", reject);
+  });
+}
+async function getOrStartTabDaemon(targetId) {
+  const sp = sockPath(targetId);
+  try {
+    return await connectToSocket(sp);
+  } catch {}
+  try {
+    unlinkSync(sp);
+  } catch {}
+  const child = spawn(nodeRuntimeCommand(), [process.argv[1], "_daemon", targetId], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  const backoffSchedule = [50, 100, 200];
+  const deadline = Date.now() + DAEMON_CONNECT_RETRIES * DAEMON_CONNECT_DELAY;
+  let attempt = 0;
+  while (Date.now() < deadline) {
+    try {
+      return await connectToSocket(sp);
+    } catch {}
+    const delay = backoffSchedule[attempt] ?? DAEMON_CONNECT_DELAY;
+    attempt++;
+    await sleep(delay);
+  }
+  throw new Error("Daemon failed to start — did you click Allow in Chrome?");
+}
+function sendCommand(conn, req) {
+  return new Promise((resolve, reject) => {
+    let buf = "";
+    let settled = false;
+    const cleanup = () => {
+      conn.off("data", onData);
+      conn.off("error", onError);
+      conn.off("end", onEnd);
+      conn.off("close", onClose);
+    };
+    const onData = (chunk) => {
+      buf += chunk.toString();
+      const idx = buf.indexOf(`
+`);
+      if (idx === -1)
+        return;
+      settled = true;
+      cleanup();
+      try {
+        resolve(JSON.parse(buf.slice(0, idx)));
+      } catch (error) {
+        reject(new Error(`Invalid JSON response from daemon: ${error.message}`));
+      }
+      conn.end();
+    };
+    const onError = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    const onEnd = () => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(new Error("Connection closed before response"));
+    };
+    const onClose = () => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(new Error("Connection closed before response"));
+    };
+    conn.on("data", onData);
+    conn.on("error", onError);
+    conn.on("end", onEnd);
+    conn.on("close", onClose);
+    req.id = 1;
+    conn.write(`${JSON.stringify(req)}
+`);
+  });
+}
+function findAnyDaemonSocket() {
+  return listDaemonSockets()[0]?.socketPath || null;
+}
+async function stopDaemons(targetPrefix) {
+  const daemons = listDaemonSockets();
+  if (targetPrefix) {
+    const targetId = resolvePrefix(targetPrefix, daemons.map((d) => d.targetId), "daemon");
+    const daemon = daemons.find((d) => d.targetId === targetId);
+    try {
+      const conn = await connectToSocket(daemon.socketPath);
+      await sendCommand(conn, { cmd: "stop" });
+    } catch {
+      try {
+        unlinkSync(daemon.socketPath);
+      } catch {}
+    }
+    return;
+  }
+  for (const daemon of daemons) {
+    try {
+      const conn = await connectToSocket(daemon.socketPath);
+      await sendCommand(conn, { cmd: "stop" });
+    } catch {
+      try {
+        unlinkSync(daemon.socketPath);
+      } catch {}
+    }
+  }
+}
+const USAGE = `cdp - lightweight Chrome DevTools Protocol CLI (no Puppeteer)
 
 Usage: cdp <command> [args]
 
@@ -56,5 +787,140 @@ Usage: cdp <command> [args]
   evalraw <target> <method> [json]  Send a raw CDP command; returns JSON result
   browse  <target> <method> [json]  Send a browser-level CDP command (no session)
   stop  [target]                    Stop daemon(s)
-`,pQ=new Set(["snap","snapshot","eval","shot","screenshot","html","nav","navigate","net","network","click","clickxy","type","loadall","evalraw","browse","browserraw"]);async function lQ(){let[Q,...z]=process.argv.slice(2);if(Q==="_daemon"){await EQ(z[0]);return}if(!Q||Q==="help"||Q==="--help"||Q==="-h")console.log(t),process.exit(0);if(Q==="list"||Q==="ls"){let b,K=gQ();if(K)try{let B=await G(K),J=await F(B,{cmd:"list_raw"});if(J.ok)b=JSON.parse(J.result)}catch{}if(!b){let B=new h;await B.connect(VQ()),b=await x(B),B.close()}s(N,JSON.stringify(b)),console.log(zQ(b)),process.exit(0)}if(Q==="stop"){await mQ(z[0]);return}if(!pQ.has(Q))console.error(`Unknown command: ${Q}
-`),console.log(t),process.exit(1);let $=z[0];if(!$)console.error('Error: target ID required. Run "cdp list" first.'),process.exit(1);let V,X=S().map((b)=>b.targetId);if(X.filter((b)=>b.toUpperCase().startsWith($.toUpperCase())).length>0)V=_($,X,"daemon");else{if(!d(N))console.error('No page list cached. Run "cdp list" first.'),process.exit(1);let b=JSON.parse(v(N,"utf8"));V=_($,b.map((K)=>K.targetId),"target",'Run "cdp list".')}let Z=await IQ(V),q=z.slice(1);if(Q==="eval"){let b=q.join(" ");if(!b)console.error("Error: expression required"),process.exit(1);q[0]=b}else if(Q==="type"){let b=q.join(" ");if(q[0]==="--stdin")b=await new Promise((K)=>{let B="";if(process.stdin.setEncoding("utf8"),process.stdin.on("data",(J)=>B+=J),process.stdin.on("end",()=>K(B)),process.stdin.isTTY)K("")});if(!b)console.error("Error: text required"),process.exit(1);q[0]=b}else if(Q==="evalraw"){if(!q[0])console.error("Error: CDP method required"),process.exit(1);if(q.length>2)q[1]=q.slice(1).join(" ")}else if(Q==="browse"||Q==="browserraw"){if(!q[0])console.error("Error: browser CDP method required"),process.exit(1);if(q.length>2)q[1]=q.slice(1).join(" ")}if((Q==="nav"||Q==="navigate")&&!q[0])console.error("Error: URL required"),process.exit(1);let H=await F(Z,{cmd:Q,args:q});if(H.ok){if(H.result)console.log(H.result)}else console.error("Error:",H.error),process.exitCode=1}lQ().catch((Q)=>{console.error(Q.message),process.exit(1)});
+`;
+const NEEDS_TARGET = new Set([
+  "snap",
+  "snapshot",
+  "eval",
+  "shot",
+  "screenshot",
+  "html",
+  "nav",
+  "navigate",
+  "net",
+  "network",
+  "click",
+  "clickxy",
+  "type",
+  "loadall",
+  "evalraw",
+  "browse",
+  "browserraw"
+]);
+async function main() {
+  const [cmd, ...args] = process.argv.slice(2);
+  if (cmd === "_daemon") {
+    await runDaemon(args[0]);
+    return;
+  }
+  if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
+    console.log(USAGE);
+    process.exit(0);
+  }
+  if (cmd === "list" || cmd === "ls") {
+    let pages;
+    const existingSock = findAnyDaemonSocket();
+    if (existingSock) {
+      try {
+        const conn = await connectToSocket(existingSock);
+        const resp = await sendCommand(conn, { cmd: "list_raw" });
+        if (resp.ok)
+          pages = JSON.parse(resp.result);
+      } catch {}
+    }
+    if (!pages) {
+      const cdp = new CDP;
+      await cdp.connect(getWsUrl());
+      pages = await getPages(cdp);
+      cdp.close();
+    }
+    writeFileSync(PAGES_CACHE, JSON.stringify(pages));
+    console.log(formatPageList(pages));
+    process.exit(0);
+  }
+  if (cmd === "stop") {
+    await stopDaemons(args[0]);
+    return;
+  }
+  if (!NEEDS_TARGET.has(cmd)) {
+    console.error(`Unknown command: ${cmd}
+`);
+    console.log(USAGE);
+    process.exit(1);
+  }
+  const targetPrefix = args[0];
+  if (!targetPrefix) {
+    console.error('Error: target ID required. Run "cdp list" first.');
+    process.exit(1);
+  }
+  let targetId;
+  const daemonTargetIds = listDaemonSockets().map((d) => d.targetId);
+  const daemonMatches = daemonTargetIds.filter((id) => id.toUpperCase().startsWith(targetPrefix.toUpperCase()));
+  if (daemonMatches.length > 0) {
+    targetId = resolvePrefix(targetPrefix, daemonTargetIds, "daemon");
+  } else {
+    if (!existsSync(PAGES_CACHE)) {
+      console.error('No page list cached. Run "cdp list" first.');
+      process.exit(1);
+    }
+    const pages = JSON.parse(readFileSync(PAGES_CACHE, "utf8"));
+    targetId = resolvePrefix(targetPrefix, pages.map((p) => p.targetId), "target", 'Run "cdp list".');
+  }
+  const conn = await getOrStartTabDaemon(targetId);
+  const cmdArgs = args.slice(1);
+  if (cmd === "eval") {
+    const expr = cmdArgs.join(" ");
+    if (!expr) {
+      console.error("Error: expression required");
+      process.exit(1);
+    }
+    cmdArgs[0] = expr;
+  } else if (cmd === "type") {
+    let text = cmdArgs.join(" ");
+    if (cmdArgs[0] === "--stdin") {
+      text = await new Promise((resolve) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => data += chunk);
+        process.stdin.on("end", () => resolve(data));
+        if (process.stdin.isTTY)
+          resolve("");
+      });
+    }
+    if (!text) {
+      console.error("Error: text required");
+      process.exit(1);
+    }
+    cmdArgs[0] = text;
+  } else if (cmd === "evalraw") {
+    if (!cmdArgs[0]) {
+      console.error("Error: CDP method required");
+      process.exit(1);
+    }
+    if (cmdArgs.length > 2)
+      cmdArgs[1] = cmdArgs.slice(1).join(" ");
+  } else if (cmd === "browse" || cmd === "browserraw") {
+    if (!cmdArgs[0]) {
+      console.error("Error: browser CDP method required");
+      process.exit(1);
+    }
+    if (cmdArgs.length > 2)
+      cmdArgs[1] = cmdArgs.slice(1).join(" ");
+  }
+  if ((cmd === "nav" || cmd === "navigate") && !cmdArgs[0]) {
+    console.error("Error: URL required");
+    process.exit(1);
+  }
+  const response = await sendCommand(conn, { cmd, args: cmdArgs });
+  if (response.ok) {
+    if (response.result)
+      console.log(response.result);
+  } else {
+    console.error("Error:", response.error);
+    process.exitCode = 1;
+  }
+}
+main().catch((e) => {
+  console.error(e.message);
+  process.exit(1);
+});