agent-dbg 0.1.9 → 0.2.0

package/dist/main.js

@@ -7631,6 +7631,9 @@ class CdpClient {
       ws.addEventListener("error", onError, { once: true });
     });
   }
+  async sendRaw(method, params) {
+    return this.send(method, params);
+  }
   async send(method, ...args) {
     if (!this.isConnected) {
       throw new Error("CDP client is not connected");
@@ -7670,13 +7673,39 @@ class CdpClient {
       }
     }
   }
+  waitFor(event, opts) {
+    const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+    const filter = opts?.filter;
+    return new Promise((resolve, reject) => {
+      const handler = (params) => {
+        if (filter && !filter(params))
+          return;
+        cleanup();
+        resolve(params);
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error(`waitFor timed out: ${event} (after ${timeoutMs}ms)`));
+      }, timeoutMs);
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.off(event, handler);
+      };
+      this.on(event, handler);
+    });
+  }
+  enabledDomains = new Set;
   async enableDomains() {
-    await Promise.all([
-      this.send("Debugger.enable"),
-      this.send("Runtime.enable"),
-      this.send("Profiler.enable"),
-      this.send("HeapProfiler.enable")
-    ]);
+    await Promise.all([this.send("Debugger.enable"), this.send("Runtime.enable")]);
+    this.enabledDomains.add("Debugger");
+    this.enabledDomains.add("Runtime");
+    const optional2 = ["Profiler", "HeapProfiler"];
+    await Promise.allSettled(optional2.map(async (domain) => {
+      try {
+        await this.send(`${domain}.enable`);
+        this.enabledDomains.add(domain);
+      } catch {}
+    }));
   }
   async runIfWaitingForDebugger() {
     await this.send("Runtime.runIfWaitingForDebugger");
@@ -8765,6 +8794,237 @@ var init_resolver = __esm(() => {
   init_trace_mapping();
 });
 
+// src/cdp/jsc-client.ts
+class JscClient {
+  cdp;
+  constructor(cdp) {
+    this.cdp = cdp;
+  }
+  async send(method, ...args) {
+    const params = args[0];
+    return this.cdp.sendRaw(method, params);
+  }
+  on(event, handler) {
+    this.cdp.on(event, handler);
+  }
+  off(event, handler) {
+    this.cdp.off(event, handler);
+  }
+  waitFor(event, opts) {
+    return this.cdp.waitFor(event, opts);
+  }
+  disconnect() {
+    this.cdp.disconnect();
+  }
+  get connected() {
+    return this.cdp.connected;
+  }
+}
+
+// src/daemon/adapters/bun-adapter.ts
+class BunAdapter {
+  name = "bun";
+  internalUrlPrefix = "bun:";
+  jsc = null;
+  async preEnable(cdp) {
+    this.jsc = new JscClient(cdp);
+    await this.jsc.send("Inspector.enable");
+  }
+  async waitForBrkPause(session) {
+    if (!this.jsc)
+      return;
+    await this.jsc.send("Debugger.setBreakpointsActive", { active: true });
+    await this.jsc.send("Debugger.setPauseForInternalScripts", { shouldPause: false });
+    const entryScript = this.resolveEntryScript(session);
+    const tempBpId = await this.setEntryBreakpoint(entryScript);
+    try {
+      const waiter = session.createPauseWaiter(5000);
+      await this.jsc.send("Inspector.initialized");
+      await waiter;
+    } finally {
+      if (tempBpId && this.jsc.connected) {
+        try {
+          await this.jsc.send("Debugger.removeBreakpoint", { breakpointId: tempBpId });
+        } catch {}
+      }
+    }
+  }
+  async setBreakpointByLocation(_cdp, params) {
+    const jsc = this.ensureJsc();
+    const scriptId = params.scriptId ?? this.findScriptId(params.scripts, params.url);
+    if (!scriptId) {
+      throw new Error(`Cannot find script for "${params.file}" \u2014 ensure the script is loaded`);
+    }
+    const r = await jsc.send("Debugger.setBreakpoint", {
+      location: {
+        scriptId,
+        lineNumber: params.line - 1,
+        columnNumber: params.column
+      },
+      options: params.condition ? { condition: params.condition } : undefined
+    });
+    return {
+      breakpointId: r.breakpointId,
+      location: r.actualLocation,
+      url: params.url
+    };
+  }
+  async getBreakableLocations(_cdp, scriptId, startLine, endLine) {
+    const jsc = this.ensureJsc();
+    const r = await jsc.send("Debugger.getBreakpointLocations", {
+      start: { scriptId, lineNumber: startLine - 1 },
+      end: { scriptId, lineNumber: endLine }
+    });
+    return (r.locations ?? []).map((loc) => ({
+      line: loc.lineNumber + 1,
+      column: (loc.columnNumber ?? 0) + 1
+    }));
+  }
+  async getProperties(cdp, params) {
+    const raw = await cdp.sendRaw("Runtime.getProperties", params);
+    if ("properties" in raw && !("result" in raw)) {
+      raw.result = raw.properties;
+      delete raw.properties;
+    }
+    return raw;
+  }
+  async setBlackboxPatterns(_cdp, patterns) {
+    const jsc = this.ensureJsc();
+    for (const pattern of patterns) {
+      await jsc.send("Debugger.setShouldBlackboxURL", {
+        url: pattern,
+        caseSensitive: false,
+        shouldBlackbox: true
+      });
+    }
+  }
+  ensureJsc() {
+    if (!this.jsc)
+      throw new Error("JscClient not initialized \u2014 call preEnable first");
+    return this.jsc;
+  }
+  async setEntryBreakpoint(entryScript) {
+    if (!entryScript || !this.jsc)
+      return null;
+    const parts = entryScript.split("/");
+    const filename = parts[parts.length - 1] ?? entryScript;
+    const urlRegex2 = `${escapeRegex2(filename)}$`;
+    try {
+      const r = await this.jsc.send("Debugger.setBreakpointByUrl", {
+        urlRegex: urlRegex2,
+        lineNumber: 1
+      });
+      return r.breakpointId;
+    } catch {
+      return null;
+    }
+  }
+  findScriptId(scripts, url2) {
+    if (!url2)
+      return;
+    for (const [sid, info] of scripts) {
+      if (info.url === url2)
+        return sid;
+    }
+    return;
+  }
+  resolveEntryScript(session) {
+    if (!session.launchCommand)
+      return null;
+    for (let i = session.launchCommand.length - 1;i >= 0; i--) {
+      const arg = session.launchCommand[i];
+      if (!arg.startsWith("-"))
+        return arg;
+    }
+    return null;
+  }
+}
+function escapeRegex2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var init_bun_adapter = () => {};
+
+// src/daemon/adapters/node-adapter.ts
+class NodeAdapter {
+  name = "node";
+  internalUrlPrefix = "node:";
+  async preEnable(_cdp) {}
+  async waitForBrkPause(session) {
+    if (!session.isPaused()) {
+      await Bun.sleep(100);
+    }
+    if (!session.isPaused() && session.cdp) {
+      await session.cdp.send("Debugger.pause");
+      await session.cdp.send("Runtime.runIfWaitingForDebugger");
+      const deadline = Date.now() + 2000;
+      while (!session.isPaused() && Date.now() < deadline) {
+        await Bun.sleep(50);
+      }
+    }
+    await this.skipInternalPauses(session);
+  }
+  async setBreakpointByLocation(cdp, params) {
+    const bpParams = {
+      lineNumber: params.line - 1
+    };
+    if (params.column !== undefined) {
+      bpParams.columnNumber = params.column;
+    }
+    if (params.urlRegex) {
+      bpParams.urlRegex = params.urlRegex;
+    } else if (params.url) {
+      bpParams.url = params.url;
+    }
+    if (params.condition) {
+      bpParams.condition = params.condition;
+    }
+    const r = await cdp.send("Debugger.setBreakpointByUrl", bpParams);
+    const loc = r.locations[0];
+    return {
+      breakpointId: r.breakpointId,
+      location: loc ? { scriptId: loc.scriptId, lineNumber: loc.lineNumber, columnNumber: loc.columnNumber } : undefined,
+      url: params.url
+    };
+  }
+  async getBreakableLocations(cdp, scriptId, startLine, endLine) {
+    const r = await cdp.send("Debugger.getPossibleBreakpoints", {
+      start: { scriptId, lineNumber: startLine - 1 },
+      end: { scriptId, lineNumber: endLine }
+    });
+    return r.locations.map((loc) => ({
+      line: loc.lineNumber + 1,
+      column: (loc.columnNumber ?? 0) + 1
+    }));
+  }
+  async getProperties(cdp, params) {
+    return cdp.send("Runtime.getProperties", params);
+  }
+  async setBlackboxPatterns(cdp, patterns) {
+    await cdp.send("Debugger.setBlackboxPatterns", { patterns });
+  }
+  async skipInternalPauses(session) {
+    let skips = 0;
+    while (session.isPaused() && session.cdp && session.pauseInfo?.url?.startsWith(this.internalUrlPrefix) && skips < 5) {
+      skips++;
+      const waiter = session.createPauseWaiter(5000);
+      await session.cdp.send("Debugger.resume");
+      await waiter;
+    }
+  }
+}
+
+// src/daemon/adapters/index.ts
+function createAdapter(command) {
+  const bin = command[0]?.split("/").pop();
+  if (bin === "bun" || bin === "bunx")
+    return new BunAdapter;
+  return new NodeAdapter;
+}
+var init_adapters = __esm(() => {
+  init_bun_adapter();
+  init_bun_adapter();
+});
+
 // src/daemon/session-blackbox.ts
 async function addBlackbox(session, patterns) {
   if (!session.cdp) {
@@ -8775,9 +9035,7 @@ async function addBlackbox(session, patterns) {
       session.blackboxPatterns.push(p);
     }
   }
-  await session.cdp.send("Debugger.setBlackboxPatterns", {
-    patterns: session.blackboxPatterns
-  });
+  await session.adapter.setBlackboxPatterns(session.cdp, session.blackboxPatterns);
   return [...session.blackboxPatterns];
 }
 function listBlackbox(session) {
@@ -8792,9 +9050,7 @@ async function removeBlackbox(session, patterns) {
   } else {
     session.blackboxPatterns = session.blackboxPatterns.filter((p) => !patterns.includes(p));
   }
-  await session.cdp.send("Debugger.setBlackboxPatterns", {
-    patterns: session.blackboxPatterns
-  });
+  await session.adapter.setBlackboxPatterns(session.cdp, session.blackboxPatterns);
   return [...session.blackboxPatterns];
 }
 
@@ -8809,6 +9065,7 @@ async function setBreakpoint(session, file2, line, options) {
   let actualLine = line;
   let actualColumn = options?.column !== undefined ? options.column - 1 : undefined;
   let actualFile = file2;
+  let generatedScriptId = null;
   if (!options?.urlRegex) {
     const generated = session.sourceMapResolver.toGenerated(file2, line, actualColumn ?? 0);
     if (generated) {
@@ -8816,34 +9073,37 @@ async function setBreakpoint(session, file2, line, options) {
       originalLine = line;
       actualLine = generated.line;
       actualColumn = generated.column;
+      generatedScriptId = generated.scriptId;
       const scriptInfo = session.scripts.get(generated.scriptId);
       if (scriptInfo) {
         actualFile = scriptInfo.url;
       }
     }
   }
-  const params = {
-    lineNumber: actualLine - 1
-  };
-  if (actualColumn !== undefined) {
-    params.columnNumber = actualColumn;
-  }
   let url2 = null;
+  let urlRegex2;
   if (options?.urlRegex) {
-    params.urlRegex = options.urlRegex;
+    urlRegex2 = options.urlRegex;
   } else {
     url2 = session.findScriptUrl(actualFile);
-    if (url2) {
-      params.url = url2;
-    } else {
-      params.urlRegex = `${actualFile.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`;
-    }
-  }
-  if (condition) {
-    params.condition = condition;
-  }
-  const r = await session.cdp.send("Debugger.setBreakpointByUrl", params);
-  const loc = r.locations[0];
+    if (!url2 && !generatedScriptId) {
+      urlRegex2 = `${actualFile.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`;
+    }
+  }
+  const r = await session.adapter.setBreakpointByLocation(session.cdp, {
+    file: file2,
+    line: actualLine,
+    column: actualColumn,
+    condition,
+    url: url2 ?? undefined,
+    urlRegex: urlRegex2,
+    scriptId: generatedScriptId ?? undefined,
+    scripts: session.scripts
+  });
+  const breakpointId = r.breakpointId;
+  const loc = r.location;
+  if (!url2)
+    url2 = r.url ?? session.findScriptUrl(actualFile);
   const resolvedUrl = originalFile ?? url2 ?? file2;
   const resolvedLine = originalLine ?? (loc ? loc.lineNumber + 1 : line);
   const resolvedColumn = loc?.columnNumber;
@@ -8869,7 +9129,7 @@ async function setBreakpoint(session, file2, line, options) {
   if (options?.urlRegex) {
     meta.urlRegex = options.urlRegex;
   }
-  const ref = session.refs.addBreakpoint(r.breakpointId, meta);
+  const ref = session.refs.addBreakpoint(breakpointId, meta);
   const location = {
     url: resolvedUrl,
     line: resolvedLine
@@ -9025,18 +9285,24 @@ async function reEnableBreakpoint(session, ref, entry) {
   const hitCount = meta.hitCount;
   const urlRegex2 = meta.urlRegex;
   const builtCondition = session.buildBreakpointCondition(condition, hitCount);
-  const bpParams = {
-    lineNumber: line - 1
-  };
-  if (urlRegex2) {
-    bpParams.urlRegex = urlRegex2;
-  } else if (url2) {
-    bpParams.url = url2;
-  }
-  if (builtCondition) {
-    bpParams.condition = builtCondition;
+  let scriptId;
+  if (url2) {
+    for (const [sid, info] of session.scripts) {
+      if (info.url === url2) {
+        scriptId = sid;
+        break;
+      }
+    }
   }
-  const r = await session.cdp.send("Debugger.setBreakpointByUrl", bpParams);
+  const r = await session.adapter.setBreakpointByLocation(session.cdp, {
+    file: url2 ?? urlRegex2 ?? "",
+    line,
+    condition: builtCondition,
+    url: url2,
+    urlRegex: urlRegex2,
+    scriptId,
+    scripts: session.scripts
+  });
   const type = meta.type === "LP" ? "LP" : "BP";
   const newMeta = { ...meta };
   delete newMeta.type;
@@ -9065,14 +9331,7 @@ async function getBreakableLocations(session, file2, startLine, endLine) {
   if (!scriptId) {
     throw new Error(`No scriptId found for "${file2}"`);
   }
-  const r = await session.cdp.send("Debugger.getPossibleBreakpoints", {
-    start: { scriptId, lineNumber: startLine - 1 },
-    end: { scriptId, lineNumber: endLine }
-  });
-  return r.locations.map((loc) => ({
-    line: loc.lineNumber + 1,
-    column: (loc.columnNumber ?? 0) + 1
-  }));
+  return session.adapter.getBreakableLocations(session.cdp, scriptId, startLine, endLine);
 }
 async function setLogpoint(session, file2, line, template, options) {
   if (!session.cdp) {
@@ -9085,17 +9344,29 @@ async function setLogpoint(session, file2, line, template, options) {
   } else {
     logExpr = `${logExpr}, false`;
   }
-  const lpParams = {
-    lineNumber: line - 1,
-    condition: logExpr
-  };
+  let urlRegex2;
+  if (!url2) {
+    urlRegex2 = `${file2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`;
+  }
+  let scriptId;
   if (url2) {
-    lpParams.url = url2;
-  } else {
-    lpParams.urlRegex = `${file2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`;
+    for (const [sid, info] of session.scripts) {
+      if (info.url === url2) {
+        scriptId = sid;
+        break;
+      }
+    }
   }
-  const r = await session.cdp.send("Debugger.setBreakpointByUrl", lpParams);
-  const loc = r.locations[0];
+  const r = await session.adapter.setBreakpointByLocation(session.cdp, {
+    file: file2,
+    line,
+    condition: logExpr,
+    url: url2 ?? undefined,
+    urlRegex: urlRegex2,
+    scriptId,
+    scripts: session.scripts
+  });
+  const loc = r.location;
   const resolvedUrl = url2 ?? file2;
   const resolvedLine = loc ? loc.lineNumber + 1 : line;
   const resolvedColumn = loc?.columnNumber;
@@ -9364,7 +9635,7 @@ async function getVars(session, options = {}) {
       const objectId = scopeObj.objectId;
       if (!objectId)
         continue;
-      const propsResult = await session.cdp.send("Runtime.getProperties", {
+      const propsResult = await session.adapter.getProperties(session.cdp, {
         objectId,
         ownProperties: true,
         generatePreview: true
@@ -9417,7 +9688,7 @@ async function getProps(session, ref, options = {}) {
   if (options.internal) {
     propsParams.accessorPropertiesOnly = false;
   }
-  const propsResult = await session.cdp.send("Runtime.getProperties", propsParams);
+  const propsResult = await session.adapter.getProperties(session.cdp, propsParams);
   const properties = propsResult.result ?? [];
   const internalProps = options.internal ? propsResult.internalProperties ?? [] : [];
   const result = [];
@@ -9995,7 +10266,7 @@ async function buildState(session, options = {}) {
             const objectId = scopeObj.objectId;
             if (!objectId)
               continue;
-            const propsResult = await session.cdp.send("Runtime.getProperties", {
+            const propsResult = await session.adapter.getProperties(session.cdp, {
               objectId,
               ownProperties: true,
               generatePreview: true
@@ -10053,6 +10324,7 @@ class DebugSession {
   disabledBreakpoints = new Map;
   launchCommand = null;
   launchOptions = null;
+  adapter;
   cdpLogger;
   daemonLogger;
   constructor(session, options) {
@@ -10060,6 +10332,10 @@ class DebugSession {
     ensureSocketDir();
     this.cdpLogger = new CdpLogger(getLogPath(session));
     this.daemonLogger = options?.daemonLogger ?? new DaemonLogger(getDaemonLogPath(session));
+    this.adapter = createAdapter(["node"]);
+  }
+  get runtime() {
+    return this.adapter.name;
   }
   async launch(command, options = {}) {
     if (this.state !== "idle") {
@@ -10070,12 +10346,13 @@ class DebugSession {
     }
     this.launchCommand = command;
     this.launchOptions = options;
+    this.adapter = createAdapter(command);
     const brk = options.brk ?? true;
     const port = options.port ?? 0;
     const inspectFlag = brk ? `--inspect-brk=${port}` : `--inspect=${port}`;
-    const runtime = command[0];
+    const runtimeBin = command[0];
     const rest = command.slice(1);
-    const spawnArgs = [runtime, inspectFlag, ...rest];
+    const spawnArgs = [runtimeBin, inspectFlag, ...rest];
     const proc = Bun.spawn(spawnArgs, {
       stdin: "ignore",
       stdout: "ignore",
@@ -10102,7 +10379,18 @@ class DebugSession {
       paused: this.sessionState === "paused"
     };
     if (this.pauseInfo) {
-      result.pauseInfo = this.pauseInfo;
+      const translated = { ...this.pauseInfo };
+      if (translated.scriptId && translated.line !== undefined) {
+        const resolved = this.resolveOriginalLocation(translated.scriptId, translated.line + 1, translated.column ?? 0);
+        if (resolved) {
+          translated.url = resolved.url;
+          translated.line = resolved.line - 1;
+          if (resolved.column !== undefined) {
+            translated.column = resolved.column - 1;
+          }
+        }
+      }
+      result.pauseInfo = translated;
     }
     return result;
   }
@@ -10338,24 +10626,16 @@ class DebugSession {
         if (settled)
           return;
         settled = true;
-        clearTimeout(timer);
         clearInterval(pollTimer);
-        this.cdp?.off("Debugger.paused", handler);
         this.onProcessExit = null;
         resolve3();
       };
-      const timer = setTimeout(() => {
-        settle();
-      }, timeoutMs);
-      const handler = () => {
-        settle();
-      };
+      this.cdp?.waitFor("Debugger.paused", { timeoutMs }).then(() => settle()).catch(() => settle());
       const pollTimer = setInterval(() => {
         if (this.isPaused() || this.state === "idle") {
           settle();
         }
       }, 100);
-      this.cdp?.on("Debugger.paused", handler);
       this.onProcessExit = settle;
     });
   }
@@ -10385,24 +10665,7 @@ class DebugSession {
     return this.state === "paused";
   }
   async waitForBrkPause() {
-    if (!this.isPaused()) {
-      await Bun.sleep(100);
-    }
-    if (!this.isPaused() && this.cdp) {
-      await this.cdp.send("Debugger.pause");
-      await this.cdp.send("Runtime.runIfWaitingForDebugger");
-      const deadline = Date.now() + 2000;
-      while (!this.isPaused() && Date.now() < deadline) {
-        await Bun.sleep(50);
-      }
-    }
-    let skips = 0;
-    while (this.isPaused() && this.cdp && this.pauseInfo?.url?.startsWith("node:") && skips < 5) {
-      skips++;
-      const waiter = this.createPauseWaiter(5000);
-      await this.cdp.send("Debugger.resume");
-      await waiter;
-    }
+    return this.adapter.waitForBrkPause(this);
   }
   async connectCdp(wsUrl) {
     this.daemonLogger.debug("cdp.connecting", `Connecting to ${wsUrl}`);
@@ -10410,11 +10673,10 @@ class DebugSession {
     this.cdp = cdp;
     this.daemonLogger.info("cdp.connected", `CDP connected to ${wsUrl}`);
     this.setupCdpEventHandlers(cdp);
+    await this.adapter.preEnable(cdp);
     await cdp.enableDomains();
     if (this.blackboxPatterns.length > 0) {
-      await cdp.send("Debugger.setBlackboxPatterns", {
-        patterns: this.blackboxPatterns
-      });
+      await this.adapter.setBlackboxPatterns(cdp, this.blackboxPatterns);
     }
     if (this.state === "idle") {
       this.state = "running";
@@ -10605,12 +10867,13 @@ var init_session2 = __esm(() => {
   init_logger2();
   init_ref_table();
   init_resolver();
+  init_adapters();
   init_logger();
   init_paths();
   init_session_inspection();
   init_session_mutation();
   init_session_state();
-  INSPECTOR_URL_REGEX = /Debugger listening on (wss?:\/\/\S+)/;
+  INSPECTOR_URL_REGEX = /(?:Debugger listening on\s+)?(wss?:\/\/\S+)/;
 });
 
 // src/daemon/entry.ts
@@ -11416,8 +11679,9 @@ function formatSource(lines) {
     const trimmed = line.isCurrent ? trimLine(line.content, line.currentColumn) : trimLine(line.content);
     result.push(`${marker} ${num}\u2502${trimmed.text}`);
     if (line.isCurrent && trimmed.caretOffset !== undefined && trimmed.caretOffset >= 0) {
-      const gutterWidth = numWidth + 4;
-      result.push(`${" ".repeat(gutterWidth)}${" ".repeat(trimmed.caretOffset)}^`);
+      const gutter = " ".repeat(numWidth + 4);
+      const indent = trimmed.text.slice(0, trimmed.caretOffset).replace(/[^\t]/g, " ");
+      result.push(`${gutter}${indent}^`);
     }
   }
   return result.join(`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dbg",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "Node.js Debugger CLI for AI Agents",
   "type": "module",
   "bin": {
@@ -12,7 +12,8 @@
     "test": "bun test",
     "lint": "biome check .",
     "format": "biome check --write .",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "update-jsc-protocol": "curl -sL https://raw.githubusercontent.com/oven-sh/bun/main/packages/bun-inspector-protocol/src/protocol/jsc/index.d.ts -o src/cdp/jsc-protocol.d.ts"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.14",