agent-dbg 0.1.2 → 0.1.3

package/.claude/settings.local.json

@@ -17,7 +17,9 @@
       "Bash(grep:*)",
       "Bash(npm view:*)",
       "Bash(find:*)",
-      "Bash(xargs sed:*)"
+      "Bash(xargs sed:*)",
+      "Bash(ps:*)",
+      "Bash(ls:*)"
     ]
   }
 }

package/.claude/skills/agent-dbg/SKILL.md

@@ -20,6 +20,8 @@ description: >
 ```bash
 # 1. Launch with breakpoint at first line
 agent-dbg launch --brk node app.js
+# Or attach to a running node process with the --inspect flag
+agent-dbg attach 9229
 
 # 2. Set breakpoints at suspicious locations
 agent-dbg break src/handler.ts:42

package/.claude/skills/agent-dbg/references/commands.md

@@ -111,7 +111,8 @@ agent-dbg exceptions --since 3            # Last 3 exceptions
 ## Breakpoints
 
 ```bash
-agent-dbg break <file>:<line>             # Set breakpoint
+agent-dbg break <file>:<line>                       # Set breakpoint
+agent-dbg break <file>:<line>:<column>              # Set breakpoint
 agent-dbg break src/app.ts:42 --condition "x > 10"  # Conditional
 agent-dbg break src/app.ts:42 --hit-count 5         # Break on Nth hit
 agent-dbg break src/app.ts:42 --continue            # Log but don't pause

package/bun.lock

@@ -0,0 +1,60 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "ndbg",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.31",
+        "zod": "^4.0.0",
+      },
+      "devDependencies": {
+        "@biomejs/biome": "^2.3.14",
+        "@types/bun": "latest",
+        "devtools-protocol": "^0.0.1581282",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
+  },
+  "packages": {
+    "@biomejs/biome": ["@biomejs/biome@2.3.14", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.3.14", "@biomejs/cli-darwin-x64": "2.3.14", "@biomejs/cli-linux-arm64": "2.3.14", "@biomejs/cli-linux-arm64-musl": "2.3.14", "@biomejs/cli-linux-x64": "2.3.14", "@biomejs/cli-linux-x64-musl": "2.3.14", "@biomejs/cli-win32-arm64": "2.3.14", "@biomejs/cli-win32-x64": "2.3.14" }, "bin": { "biome": "bin/biome" } }, "sha512-QMT6QviX0WqXJCaiqVMiBUCr5WRQ1iFSjvOLoTk6auKukJMvnMzWucXpwZB0e8F00/1/BsS9DzcKgWH+CLqVuA=="],
+
+    "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.3.14", "", { "os": "darwin", "cpu": "arm64" }, "sha512-UJGPpvWJMkLxSRtpCAKfKh41Q4JJXisvxZL8ChN1eNW3m/WlPFJ6EFDCE7YfUb4XS8ZFi3C1dFpxUJ0Ety5n+A=="],
+
+    "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.3.14", "", { "os": "darwin", "cpu": "x64" }, "sha512-PNkLNQG6RLo8lG7QoWe/hhnMxJIt1tEimoXpGQjwS/dkdNiKBLPv4RpeQl8o3s1OKI3ZOR5XPiYtmbGGHAOnLA=="],
+
+    "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.3.14", "", { "os": "linux", "cpu": "arm64" }, "sha512-KT67FKfzIw6DNnUNdYlBg+eU24Go3n75GWK6NwU4+yJmDYFe9i/MjiI+U/iEzKvo0g7G7MZqoyrhIYuND2w8QQ=="],
+
+    "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.3.14", "", { "os": "linux", "cpu": "arm64" }, "sha512-LInRbXhYujtL3sH2TMCH/UBwJZsoGwfQjBrMfl84CD4hL/41C/EU5mldqf1yoFpsI0iPWuU83U+nB2TUUypWeg=="],
+
+    "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.3.14", "", { "os": "linux", "cpu": "x64" }, "sha512-ZsZzQsl9U+wxFrGGS4f6UxREUlgHwmEfu1IrXlgNFrNnd5Th6lIJr8KmSzu/+meSa9f4rzFrbEW9LBBA6ScoMA=="],
+
+    "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.3.14", "", { "os": "linux", "cpu": "x64" }, "sha512-KQU7EkbBBuHPW3/rAcoiVmhlPtDSGOGRPv9js7qJVpYTzjQmVR+C9Rfcz+ti8YCH+zT1J52tuBybtP4IodjxZQ=="],
+
+    "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.3.14", "", { "os": "win32", "cpu": "arm64" }, "sha512-+IKYkj/pUBbnRf1G1+RlyA3LWiDgra1xpS7H2g4BuOzzRbRB+hmlw0yFsLprHhbbt7jUzbzAbAjK/Pn0FDnh1A=="],
+
+    "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.3.14", "", { "os": "win32", "cpu": "x64" }, "sha512-oizCjdyQ3WJEswpb3Chdngeat56rIdSYK12JI3iI11Mt5T5EXcZ7WLuowzEaFPNJ3zmOQFliMN8QY1Pi+qsfdQ=="],
+
+    "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
+
+    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="],
+
+    "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
+
+    "@types/bun": ["@types/bun@1.3.8", "", { "dependencies": { "bun-types": "1.3.8" } }, "sha512-3LvWJ2q5GerAXYxO2mffLTqOzEu5qnhEAlh48Vnu8WQfnmSwbgagjGZV6BoHKJztENYEDn6QmVd949W4uESRJA=="],
+
+    "@types/node": ["@types/node@25.2.2", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-BkmoP5/FhRYek5izySdkOneRyXYN35I860MFAGupTdebyE66uZaR+bXLHq8k4DirE5DwQi3NuhvRU1jqTVwUrQ=="],
+
+    "bun-types": ["bun-types@1.3.8", "", { "dependencies": { "@types/node": "*" } }, "sha512-fL99nxdOWvV4LqjmC+8Q9kW3M4QTtTR1eePs94v5ctGqU8OeceWrSUaRw3JYb7tU3FkMIAjkueehrHPPPGKi5Q=="],
+
+    "devtools-protocol": ["devtools-protocol@0.0.1581282", "", {}, "sha512-nv7iKtNZQshSW2hKzYNr46nM/Cfh5SEvE2oV0/SEGgc9XupIY5ggf84Cz8eJIkBce7S3bmTAauFD6aysMpnqsQ=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
+
+    "zod": ["zod@4.3.6", "", {}, "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg=="],
+  }
+}

package/dist/main.js

@@ -12,6 +12,72 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// src/daemon/logger.ts
+import { appendFileSync, writeFileSync } from "fs";
+
+class DaemonLogger {
+  logPath;
+  constructor(logPath) {
+    this.logPath = logPath;
+    writeFileSync(logPath, "");
+  }
+  info(event, message, data) {
+    this.write("info", event, message, data);
+  }
+  warn(event, message, data) {
+    this.write("warn", event, message, data);
+  }
+  error(event, message, data) {
+    this.write("error", event, message, data);
+  }
+  debug(event, message, data) {
+    this.write("debug", event, message, data);
+  }
+  clear() {
+    writeFileSync(this.logPath, "");
+  }
+  write(level, event, message, data) {
+    const entry = { ts: Date.now(), level, event, message };
+    if (data !== undefined) {
+      entry.data = data;
+    }
+    appendFileSync(this.logPath, `${JSON.stringify(entry)}
+`);
+  }
+}
+var init_logger = () => {};
+
+// src/daemon/paths.ts
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+function getSocketDir() {
+  const xdgRuntime = process.env.XDG_RUNTIME_DIR;
+  if (xdgRuntime) {
+    return join(xdgRuntime, "agent-dbg");
+  }
+  const tmpdir = process.env.TMPDIR || "/tmp";
+  return join(tmpdir, `agent-dbg-${process.getuid?.() ?? 0}`);
+}
+function getSocketPath(session) {
+  return join(getSocketDir(), `${session}.sock`);
+}
+function getLockPath(session) {
+  return join(getSocketDir(), `${session}.lock`);
+}
+function getLogPath(session) {
+  return join(getSocketDir(), `${session}.cdp.log`);
+}
+function getDaemonLogPath(session) {
+  return join(getSocketDir(), `${session}.daemon.log`);
+}
+function ensureSocketDir() {
+  const dir = getSocketDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+var init_paths = () => {};
+
 // node_modules/@zod/core/dist/esm/core.js
 function $constructor(name, initializer) {
   class _ {
@@ -6308,36 +6374,8 @@ var init_messages = __esm(() => {
   DaemonResponseSchema = exports_external.union([SuccessResponse, ErrorResponse]);
 });
 
-// src/daemon/paths.ts
-import { existsSync, mkdirSync } from "fs";
-import { join } from "path";
-function getSocketDir() {
-  const xdgRuntime = process.env.XDG_RUNTIME_DIR;
-  if (xdgRuntime) {
-    return join(xdgRuntime, "agent-dbg");
-  }
-  const tmpdir = process.env.TMPDIR || "/tmp";
-  return join(tmpdir, `agent-dbg-${process.getuid?.() ?? 0}`);
-}
-function getSocketPath(session) {
-  return join(getSocketDir(), `${session}.sock`);
-}
-function getLockPath(session) {
-  return join(getSocketDir(), `${session}.lock`);
-}
-function getLogPath(session) {
-  return join(getSocketDir(), `${session}.cdp.log`);
-}
-function ensureSocketDir() {
-  const dir = getSocketDir();
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-}
-var init_paths = () => {};
-
 // src/daemon/server.ts
-import { existsSync as existsSync2, unlinkSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 
 class DaemonServer {
   session;
@@ -6347,11 +6385,13 @@ class DaemonServer {
   listener = null;
   socketPath;
   lockPath;
+  logger;
   constructor(session, options) {
     this.session = session;
     this.idleTimeout = options.idleTimeout;
     this.socketPath = getSocketPath(session);
     this.lockPath = getLockPath(session);
+    this.logger = options.logger ?? null;
   }
   onRequest(handler) {
     this.handler = handler;
@@ -6368,7 +6408,7 @@ class DaemonServer {
     if (existsSync2(this.socketPath)) {
       unlinkSync(this.socketPath);
     }
-    writeFileSync(this.lockPath, String(process.pid));
+    writeFileSync2(this.lockPath, String(process.pid));
     const server = this;
     this.listener = Bun.listen({
       unix: this.socketPath,
@@ -6389,6 +6429,7 @@ class DaemonServer {
         },
         close() {},
         error(_socket, error3) {
+          server.logger?.error("socket.error", error3.message);
           console.error(`[daemon] socket error: ${error3.message}`);
         }
       }
@@ -6457,6 +6498,7 @@ class DaemonServer {
     }
     if (this.idleTimeout > 0) {
       this.idleTimer = setTimeout(() => {
+        this.logger?.info("daemon.idle", `Idle timeout reached (${this.idleTimeout}s), shutting down`);
         this.stop();
       }, this.idleTimeout * 1000);
     }
@@ -6647,14 +6689,14 @@ class CdpClient {
 var DEFAULT_TIMEOUT_MS = 30000;
 
 // src/cdp/logger.ts
-import { appendFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { appendFileSync as appendFileSync2, writeFileSync as writeFileSync3 } from "fs";
 
 class CdpLogger {
   logPath;
   pending = new Map;
   constructor(logPath) {
     this.logPath = logPath;
-    writeFileSync2(logPath, "");
+    writeFileSync3(logPath, "");
   }
   logSend(id, method, params) {
     this.pending.set(id, { method, sentAt: Date.now() });
@@ -6687,14 +6729,14 @@ class CdpLogger {
     this.append(entry);
   }
   clear() {
-    writeFileSync2(this.logPath, "");
+    writeFileSync3(this.logPath, "");
   }
   append(entry) {
-    appendFileSync(this.logPath, `${JSON.stringify(entry)}
+    appendFileSync2(this.logPath, `${JSON.stringify(entry)}
 `);
   }
 }
-var init_logger = () => {};
+var init_logger2 = () => {};
 
 // src/formatter/values.ts
 function truncate(str, max) {
@@ -9040,10 +9082,12 @@ class DebugSession {
   launchCommand = null;
   launchOptions = null;
   cdpLogger;
-  constructor(session) {
+  daemonLogger;
+  constructor(session, options) {
     this.session = session;
     ensureSocketDir();
     this.cdpLogger = new CdpLogger(getLogPath(session));
+    this.daemonLogger = options?.daemonLogger ?? new DaemonLogger(getDaemonLogPath(session));
   }
   async launch(command, options = {}) {
     if (this.state !== "idle") {
@@ -9062,13 +9106,20 @@ class DebugSession {
     const spawnArgs = [runtime, inspectFlag, ...rest];
     const proc = Bun.spawn(spawnArgs, {
       stdin: "ignore",
-      stdout: "pipe",
+      stdout: "ignore",
       stderr: "pipe"
     });
     this.childProcess = proc;
+    this.daemonLogger.info("child.spawn", `Spawned process pid=${proc.pid}`, {
+      pid: proc.pid,
+      command: spawnArgs
+    });
     this.monitorProcessExit(proc);
     const wsUrl = await this.readInspectorUrl(proc.stderr);
     this.wsUrl = wsUrl;
+    this.daemonLogger.info("inspector.detected", `Inspector URL: ${wsUrl}`, {
+      wsUrl
+    });
     await this.connectCdp(wsUrl);
     if (brk) {
       await this.waitForBrkPause();
@@ -9382,8 +9433,10 @@ class DebugSession {
     }
   }
   async connectCdp(wsUrl) {
+    this.daemonLogger.debug("cdp.connecting", `Connecting to ${wsUrl}`);
     const cdp = await CdpClient.connect(wsUrl, this.cdpLogger);
     this.cdp = cdp;
+    this.daemonLogger.info("cdp.connected", `CDP connected to ${wsUrl}`);
     this.setupCdpEventHandlers(cdp);
     await cdp.enableDomains();
     if (this.blackboxPatterns.length > 0) {
@@ -9490,7 +9543,11 @@ class DebugSession {
     });
   }
   monitorProcessExit(proc) {
-    proc.exited.then(() => {
+    proc.exited.then((exitCode) => {
+      this.daemonLogger.info("child.exit", `Process exited with code ${exitCode ?? "unknown"}`, {
+        pid: proc.pid,
+        exitCode: exitCode ?? null
+      });
       this.childProcess = null;
       if (this.cdp) {
         this.cdp.disconnect();
@@ -9499,7 +9556,10 @@ class DebugSession {
       this.state = "idle";
       this.pauseInfo = null;
       this.onProcessExit?.();
-    }).catch(() => {
+    }).catch((err) => {
+      this.daemonLogger.error("child.exit.error", `Error waiting for process exit: ${err}`, {
+        pid: proc.pid
+      });
       this.childProcess = null;
       this.state = "idle";
       this.pauseInfo = null;
@@ -9518,16 +9578,22 @@ class DebugSession {
         if (done) {
           break;
         }
-        accumulated += decoder.decode(value, { stream: true });
+        const chunk = decoder.decode(value, { stream: true });
+        accumulated += chunk;
+        this.daemonLogger.debug("child.stderr", chunk.trimEnd());
         const match = INSPECTOR_URL_REGEX.exec(accumulated);
         if (match?.[1]) {
           clearTimeout(timeout);
-          reader.releaseLock();
+          this.drainReader(reader);
           return match[1];
         }
       }
     } catch {}
     clearTimeout(timeout);
+    this.daemonLogger.error("inspector.failed", "Failed to detect inspector URL", {
+      stderr: accumulated.slice(0, 2000),
+      timeoutMs: INSPECTOR_TIMEOUT_MS
+    });
     throw new Error(`Failed to detect inspector URL within ${INSPECTOR_TIMEOUT_MS}ms. Stderr: ${accumulated.slice(0, 500)}`);
   }
   async discoverWsUrl(port) {
@@ -9552,12 +9618,22 @@ class DebugSession {
     }
     return wsUrl;
   }
+  drainReader(reader) {
+    const pump = () => {
+      reader.read().then(({ done }) => {
+        if (!done)
+          pump();
+      }).catch(() => {});
+    };
+    pump();
+  }
 }
 var INSPECTOR_URL_REGEX, INSPECTOR_TIMEOUT_MS = 5000;
 var init_session = __esm(() => {
-  init_logger();
+  init_logger2();
   init_ref_table();
   init_resolver();
+  init_logger();
   init_paths();
   init_session_inspection();
   init_session_mutation();
@@ -9567,8 +9643,10 @@ var init_session = __esm(() => {
 
 // src/daemon/entry.ts
 var exports_entry = {};
-var daemonIdx, session, timeout = 300, timeoutIdx, server, debugSession;
+var daemonIdx, session, timeout = 300, timeoutIdx, daemonLogger, server, debugSession;
 var init_entry = __esm(async () => {
+  init_logger();
+  init_paths();
   init_server();
   init_session();
   daemonIdx = process.argv.indexOf("--daemon");
@@ -9587,8 +9665,15 @@ var init_entry = __esm(async () => {
       }
     }
   }
-  server = new DaemonServer(session, { idleTimeout: timeout });
-  debugSession = new DebugSession(session);
+  ensureSocketDir();
+  daemonLogger = new DaemonLogger(getDaemonLogPath(session));
+  daemonLogger.info("daemon.start", `Daemon starting for session "${session}"`, {
+    pid: process.pid,
+    session,
+    timeout
+  });
+  server = new DaemonServer(session, { idleTimeout: timeout, logger: daemonLogger });
+  debugSession = new DebugSession(session, { daemonLogger });
   server.onRequest(async (req) => {
     switch (req.cmd) {
       case "ping":
@@ -9790,7 +9875,7 @@ var init_registry = __esm(() => {
 });
 
 // src/daemon/client.ts
-import { existsSync as existsSync3, readdirSync } from "fs";
+import { existsSync as existsSync3, readFileSync, readdirSync, unlinkSync as unlinkSync2 } from "fs";
 
 class DaemonClient {
   session;
@@ -9890,12 +9975,28 @@ class DaemonClient {
     if (!existsSync3(socketPath)) {
       return false;
     }
+    const lockPath = getLockPath(session2);
+    if (!existsSync3(lockPath)) {
+      return false;
+    }
     try {
+      const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
+      if (Number.isNaN(pid))
+        return false;
+      process.kill(pid, 0);
       return true;
     } catch {
       return false;
     }
   }
+  static cleanStaleFiles(session2) {
+    const socketPath = getSocketPath(session2);
+    const lockPath = getLockPath(session2);
+    if (existsSync3(socketPath))
+      unlinkSync2(socketPath);
+    if (existsSync3(lockPath))
+      unlinkSync2(lockPath);
+  }
   static async isAlive(session2) {
     const socketPath = getSocketPath(session2);
     if (!existsSync3(socketPath)) {
@@ -9925,7 +10026,7 @@ var init_client = __esm(() => {
 });
 
 // src/daemon/spawn.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync4, openSync } from "fs";
 async function spawnDaemon(session2, options = {}) {
   const socketPath = getSocketPath(session2);
   const spawnArgs = [];
@@ -9940,11 +10041,13 @@ async function spawnDaemon(session2, options = {}) {
   if (options.timeout !== undefined) {
     spawnArgs.push("--timeout", String(options.timeout));
   }
+  ensureSocketDir();
+  const logFd = openSync(getDaemonLogPath(session2), "a");
   const proc = Bun.spawn(spawnArgs, {
     detached: true,
     stdin: "ignore",
-    stdout: "ignore",
-    stderr: "ignore"
+    stdout: logFd,
+    stderr: logFd
   });
   proc.unref();
   const deadline = Date.now() + SPAWN_TIMEOUT_MS;
@@ -9956,8 +10059,15 @@ async function spawnDaemon(session2, options = {}) {
   }
   throw new Error(`Daemon for session "${session2}" failed to start within ${SPAWN_TIMEOUT_MS}ms`);
 }
+async function ensureDaemon(session2, options) {
+  if (DaemonClient.isRunning(session2))
+    return;
+  DaemonClient.cleanStaleFiles(session2);
+  await spawnDaemon(session2, options);
+}
 var POLL_INTERVAL_MS = 50, SPAWN_TIMEOUT_MS = 5000;
 var init_spawn = __esm(() => {
+  init_client();
   init_paths();
 });
 
@@ -10001,9 +10111,7 @@ var init_launch = __esm(() => {
       console.error("  -> Try: agent-dbg launch --brk node app.js");
       return 1;
     }
-    if (!DaemonClient.isRunning(session2)) {
-      await spawnDaemon(session2, { timeout: timeout2 });
-    }
+    await ensureDaemon(session2, { timeout: timeout2 });
     const client = new DaemonClient(session2);
     const response = await client.request("launch", { command, brk, port });
     if (!response.ok) {
@@ -10049,7 +10157,7 @@ var init_attach = __esm(() => {
       return 1;
     }
     const timeout2 = typeof args.flags.timeout === "string" ? parseInt(args.flags.timeout, 10) : undefined;
-    await spawnDaemon(session2, { timeout: timeout2 });
+    await ensureDaemon(session2, { timeout: timeout2 });
     const client = new DaemonClient(session2);
     const response = await client.request("attach", { target });
     if (!response.ok) {
@@ -12006,7 +12114,13 @@ function formatLogEntry(entry) {
   const summary = summarizer ? summarizer(entry) : summarizeParams(entry);
   return `${time3}  <- ${entry.method}${summary ? `  ${summary}` : ""}`;
 }
-var eventSummarizers, responseSummarizers;
+function formatDaemonLogEntry(entry) {
+  const time3 = `[${formatTime(entry.ts)}]`;
+  const level = levelColors[entry.level] ?? entry.level.toUpperCase();
+  const data = entry.data ? `  ${truncate2(JSON.stringify(entry.data), 120)}` : "";
+  return `${time3} ${level} ${entry.event}: ${entry.message}${data}`;
+}
+var eventSummarizers, responseSummarizers, levelColors;
 var init_logs = __esm(() => {
   eventSummarizers = {
     "Debugger.scriptParsed": (e) => {
@@ -12063,6 +12177,12 @@ var init_logs = __esm(() => {
       return `breakpointId=${r.breakpointId}`;
     }
   };
+  levelColors = {
+    info: "INFO ",
+    warn: "WARN ",
+    error: "ERROR",
+    debug: "DEBUG"
+  };
 });
 
 // src/commands/logs.ts
@@ -12070,13 +12190,25 @@ var exports_logs = {};
 import {
   closeSync,
   existsSync as existsSync5,
-  openSync,
-  readFileSync,
+  openSync as openSync2,
+  readFileSync as readFileSync2,
   readSync,
   watch,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
-function parseEntries(text) {
+function parseCdpEntries(text) {
+  const entries = [];
+  for (const line of text.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {}
+  }
+  return entries;
+}
+function parseDaemonEntries(text) {
   const entries = [];
   for (const line of text.split(`
 `)) {
@@ -12091,7 +12223,10 @@ function parseEntries(text) {
 function filterByDomain(entries, domain) {
   return entries.filter((e) => e.method.startsWith(`${domain}.`));
 }
-function printEntries(entries, json2) {
+function filterByLevel(entries, level) {
+  return entries.filter((e) => e.level === level);
+}
+function printCdpEntries(entries, json2) {
   for (const entry of entries) {
     if (json2) {
       console.log(JSON.stringify(entry));
@@ -12100,37 +12235,56 @@ function printEntries(entries, json2) {
     }
   }
 }
+function printDaemonEntries(entries, json2) {
+  for (const entry of entries) {
+    if (json2) {
+      console.log(JSON.stringify(entry));
+    } else {
+      console.log(formatDaemonLogEntry(entry));
+    }
+  }
+}
 var init_logs2 = __esm(() => {
   init_registry();
   init_paths();
   init_logs();
   registerCommand("logs", async (args) => {
     const session2 = args.global.session;
-    const logPath = getLogPath(session2);
+    const isDaemon = args.flags.daemon === true;
+    const logPath = isDaemon ? getDaemonLogPath(session2) : getLogPath(session2);
     if (args.flags.clear === true) {
       if (existsSync5(logPath)) {
-        writeFileSync3(logPath, "");
-        console.log("Log cleared");
+        writeFileSync4(logPath, "");
+        console.log(`${isDaemon ? "Daemon log" : "Log"} cleared`);
       } else {
-        console.log("No log file to clear");
+        console.log(`No ${isDaemon ? "daemon " : ""}log file to clear`);
       }
       return 0;
     }
     if (!existsSync5(logPath)) {
-      console.error(`No log file for session "${session2}"`);
+      console.error(`No ${isDaemon ? "daemon " : ""}log file for session "${session2}"`);
       console.error("  -> Try: agent-dbg launch --brk node app.js");
       return 1;
     }
     const isJson = args.global.json;
     const domain = typeof args.flags.domain === "string" ? args.flags.domain : undefined;
+    const level = typeof args.flags.level === "string" ? args.flags.level : undefined;
     const limit = typeof args.flags.limit === "string" ? parseInt(args.flags.limit, 10) : 50;
     const follow = args.flags.follow === true;
-    const content = readFileSync(logPath, "utf-8");
-    let entries = parseEntries(content);
-    if (domain)
-      entries = filterByDomain(entries, domain);
-    const sliced = follow ? entries : entries.slice(-limit);
-    printEntries(sliced, isJson);
+    const content = readFileSync2(logPath, "utf-8");
+    if (isDaemon) {
+      let entries = parseDaemonEntries(content);
+      if (level)
+        entries = filterByLevel(entries, level);
+      const sliced = follow ? entries : entries.slice(-limit);
+      printDaemonEntries(sliced, isJson);
+    } else {
+      let entries = parseCdpEntries(content);
+      if (domain)
+        entries = filterByDomain(entries, domain);
+      const sliced = follow ? entries : entries.slice(-limit);
+      printCdpEntries(sliced, isJson);
+    }
     if (!follow)
       return 0;
     let offset = Buffer.byteLength(content, "utf-8");
@@ -12140,15 +12294,22 @@ var init_logs2 = __esm(() => {
         const size = Bun.file(logPath).size;
         if (size <= offset)
           return;
-        const fd = openSync(logPath, "r");
+        const fd = openSync2(logPath, "r");
         const buf = Buffer.alloc(size - offset);
         readSync(fd, buf, 0, buf.length, offset);
         closeSync(fd);
         offset = size;
-        let newEntries = parseEntries(buf.toString("utf-8"));
-        if (domain)
-          newEntries = filterByDomain(newEntries, domain);
-        printEntries(newEntries, isJson);
+        if (isDaemon) {
+          let newEntries = parseDaemonEntries(buf.toString("utf-8"));
+          if (level)
+            newEntries = filterByLevel(newEntries, level);
+          printDaemonEntries(newEntries, isJson);
+        } else {
+          let newEntries = parseCdpEntries(buf.toString("utf-8"));
+          if (domain)
+            newEntries = filterByDomain(newEntries, domain);
+          printCdpEntries(newEntries, isJson);
+        }
       } catch {}
     };
     watcher = watch(logPath, () => {