agent-dbg 0.1.2 → 0.1.4

package/dist/main.js

@@ -12,6 +12,1115 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// src/refs/ref-table.ts
+class RefTable {
+  entries = new Map;
+  counters = {
+    v: 1,
+    f: 0,
+    o: 1,
+    BP: 1,
+    LP: 1,
+    HS: 1
+  };
+  addVar(remoteId, name, meta) {
+    return this.add("v", remoteId, name, meta);
+  }
+  addFrame(remoteId, name, meta) {
+    return this.add("f", remoteId, name, meta);
+  }
+  addObject(remoteId, name, meta) {
+    return this.add("o", remoteId, name, meta);
+  }
+  addBreakpoint(remoteId, meta) {
+    return this.add("BP", remoteId, undefined, meta);
+  }
+  addLogpoint(remoteId, meta) {
+    return this.add("LP", remoteId, undefined, meta);
+  }
+  addHeapSnapshot(remoteId, meta) {
+    return this.add("HS", remoteId, undefined, meta);
+  }
+  resolve(ref) {
+    return this.entries.get(ref);
+  }
+  resolveId(ref) {
+    return this.entries.get(ref)?.remoteId;
+  }
+  clearVolatile() {
+    for (const [key, entry] of this.entries) {
+      if (entry.type === "v" || entry.type === "f") {
+        this.entries.delete(key);
+      }
+    }
+    this.counters.v = 1;
+    this.counters.f = 0;
+  }
+  clearObjects() {
+    for (const [key, entry] of this.entries) {
+      if (entry.type === "o") {
+        this.entries.delete(key);
+      }
+    }
+    this.counters.o = 1;
+  }
+  clearAll() {
+    this.entries.clear();
+    this.counters = { v: 1, f: 0, o: 1, BP: 1, LP: 1, HS: 1 };
+  }
+  list(type) {
+    const result = [];
+    for (const entry of this.entries.values()) {
+      if (entry.type === type) {
+        result.push(entry);
+      }
+    }
+    return result;
+  }
+  remove(ref) {
+    return this.entries.delete(ref);
+  }
+  add(type, remoteId, name, meta) {
+    const num = this.counters[type];
+    this.counters[type] = num + 1;
+    const ref = `${PREFIXES[type]}${num}`;
+    const entry = { ref, type, remoteId };
+    if (name !== undefined) {
+      entry.name = name;
+    }
+    if (meta !== undefined) {
+      entry.meta = meta;
+    }
+    this.entries.set(ref, entry);
+    return ref;
+  }
+}
+var PREFIXES;
+var init_ref_table = __esm(() => {
+  PREFIXES = {
+    v: "@v",
+    f: "@f",
+    o: "@o",
+    BP: "BP#",
+    LP: "LP#",
+    HS: "HS#"
+  };
+});
+
+// src/dap/client.ts
+class DapClient {
+  proc;
+  nextSeq = 1;
+  pending = new Map;
+  listeners = new Map;
+  isConnected = false;
+  buffer = "";
+  constructor(proc) {
+    this.proc = proc;
+    this.isConnected = true;
+    this.readLoop();
+    this.drainStderr();
+  }
+  static spawn(command) {
+    const [cmd, ...args] = command;
+    if (!cmd) {
+      throw new Error("DapClient.spawn: command array must not be empty");
+    }
+    const proc = Bun.spawn([cmd, ...args], {
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    return new DapClient(proc);
+  }
+  async send(command, args) {
+    if (!this.isConnected) {
+      throw new Error("DAP client is not connected");
+    }
+    const seq = this.nextSeq++;
+    const request = {
+      seq,
+      type: "request",
+      command
+    };
+    if (args !== undefined) {
+      request.arguments = args;
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(seq);
+        reject(new Error(`DAP request timed out: ${command} (seq=${seq})`));
+      }, DEFAULT_TIMEOUT_MS);
+      this.pending.set(seq, { resolve, reject, timer });
+      this.writeMessage(request);
+    });
+  }
+  on(event, handler) {
+    let handlers = this.listeners.get(event);
+    if (!handlers) {
+      handlers = new Set;
+      this.listeners.set(event, handlers);
+    }
+    handlers.add(handler);
+  }
+  off(event, handler) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.listeners.delete(event);
+      }
+    }
+  }
+  disconnect() {
+    if (!this.isConnected) {
+      return;
+    }
+    this.isConnected = false;
+    const error = new Error("DAP client disconnected");
+    for (const [id, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+      this.pending.delete(id);
+    }
+    this.listeners.clear();
+    try {
+      this.proc.stdin.end();
+    } catch {}
+    try {
+      this.proc.kill();
+    } catch {}
+  }
+  get connected() {
+    return this.isConnected;
+  }
+  get pid() {
+    return this.proc.pid;
+  }
+  writeMessage(msg) {
+    const json = JSON.stringify(msg);
+    const header = `Content-Length: ${Buffer.byteLength(json, "utf-8")}\r
+\r
+`;
+    try {
+      this.proc.stdin.write(header + json);
+    } catch {
+      this.isConnected = false;
+    }
+  }
+  async readLoop() {
+    const reader = this.proc.stdout.getReader();
+    const decoder = new TextDecoder;
+    try {
+      while (this.isConnected) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        this.buffer += decoder.decode(value, { stream: true });
+        this.processBuffer();
+      }
+    } catch {} finally {
+      this.isConnected = false;
+      const error = new Error("DAP adapter process terminated");
+      for (const [id, pending] of this.pending) {
+        clearTimeout(pending.timer);
+        pending.reject(error);
+        this.pending.delete(id);
+      }
+    }
+  }
+  processBuffer() {
+    while (true) {
+      const headerEnd = this.buffer.indexOf(`\r
+\r
+`);
+      if (headerEnd === -1)
+        return;
+      const header = this.buffer.slice(0, headerEnd);
+      const match = /Content-Length:\s*(\d+)/i.exec(header);
+      if (!match?.[1]) {
+        this.buffer = this.buffer.slice(headerEnd + 4);
+        continue;
+      }
+      const contentLength = parseInt(match[1], 10);
+      const bodyStart = headerEnd + 4;
+      const bodyEnd = bodyStart + contentLength;
+      if (this.buffer.length < bodyEnd)
+        return;
+      const body = this.buffer.slice(bodyStart, bodyEnd);
+      this.buffer = this.buffer.slice(bodyEnd);
+      this.handleMessage(body);
+    }
+  }
+  handleMessage(data) {
+    let parsed;
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (parsed.type === "response") {
+      const response = parsed;
+      const pending = this.pending.get(response.request_seq);
+      if (!pending)
+        return;
+      this.pending.delete(response.request_seq);
+      clearTimeout(pending.timer);
+      if (!response.success) {
+        pending.reject(new Error(`DAP error (${response.command}): ${response.message ?? "unknown error"}`));
+      } else {
+        pending.resolve(response);
+      }
+    } else if (parsed.type === "event") {
+      const event = parsed;
+      const handlers = this.listeners.get(event.event);
+      if (handlers) {
+        for (const handler of handlers) {
+          handler(event.body);
+        }
+      }
+    }
+  }
+  async drainStderr() {
+    const reader = this.proc.stderr.getReader();
+    try {
+      while (true) {
+        const { done } = await reader.read();
+        if (done)
+          break;
+      }
+    } catch {}
+  }
+}
+var DEFAULT_TIMEOUT_MS = 30000;
+
+// src/dap/session.ts
+function resolveAdapterCommand(runtime) {
+  switch (runtime) {
+    case "lldb":
+    case "lldb-dap": {
+      const brewPath = "/opt/homebrew/opt/llvm/bin/lldb-dap";
+      return [brewPath];
+    }
+    case "codelldb":
+      return ["codelldb", "--port", "0"];
+    default:
+      return [runtime];
+  }
+}
+
+class DapSession {
+  dap = null;
+  refs = new RefTable;
+  _state = "idle";
+  _pauseInfo = null;
+  _session;
+  _runtime;
+  _startTime = Date.now();
+  _threadId = 1;
+  _stackFrames = [];
+  _consoleMessages = [];
+  _exceptionEntries = [];
+  capabilities = {};
+  breakpoints = new Map;
+  allBreakpoints = [];
+  functionBreakpoints = [];
+  stoppedWaiter = null;
+  _stackFetchPromise = null;
+  constructor(session, runtime) {
+    this._session = session;
+    this._runtime = runtime;
+  }
+  async launch(command, options = {}) {
+    if (this._state !== "idle") {
+      throw new Error("Session already has an active debug target");
+    }
+    const adapterCmd = resolveAdapterCommand(this._runtime);
+    this.dap = DapClient.spawn(adapterCmd);
+    this.setupEventHandlers();
+    await this.initializeAdapter();
+    const program = options.program ?? command[0];
+    const programArgs = options.args ?? command.slice(1);
+    const launchArgs = {
+      program,
+      args: programArgs,
+      stopOnEntry: options.brk ?? true,
+      cwd: process.cwd()
+    };
+    await this.dap.send("launch", launchArgs);
+    await this.dap.send("configurationDone");
+    if (options.brk !== false) {
+      await this.waitForStop(5000);
+    }
+    const result = {
+      pid: this.dap.pid,
+      wsUrl: `dap://${this._runtime}`,
+      paused: this.isPaused()
+    };
+    if (this._pauseInfo) {
+      result.pauseInfo = this._pauseInfo;
+    }
+    return result;
+  }
+  async attach(target) {
+    if (this._state !== "idle") {
+      throw new Error("Session already has an active debug target");
+    }
+    const adapterCmd = resolveAdapterCommand(this._runtime);
+    this.dap = DapClient.spawn(adapterCmd);
+    this.setupEventHandlers();
+    await this.initializeAdapter();
+    const pid = parseInt(target, 10);
+    const attachArgs = Number.isNaN(pid) ? { program: target, waitFor: true } : { pid };
+    await this.dap.send("attach", attachArgs);
+    await this.dap.send("configurationDone");
+    await this.waitForStop(5000).catch(() => {});
+    if (this._state === "idle") {
+      this._state = "running";
+    }
+    return { wsUrl: `dap://${this._runtime}/${target}` };
+  }
+  getStatus() {
+    return {
+      session: this._session,
+      state: this._state,
+      pid: this.dap?.pid,
+      wsUrl: this.dap ? `dap://${this._runtime}` : undefined,
+      pauseInfo: this._pauseInfo ?? undefined,
+      uptime: Math.floor((Date.now() - this._startTime) / 1000),
+      scriptCount: 0
+    };
+  }
+  async stop() {
+    if (this.dap) {
+      try {
+        await this.dap.send("disconnect", { terminateDebuggee: true });
+      } catch {}
+      this.dap.disconnect();
+      this.dap = null;
+    }
+    this._state = "idle";
+    this._pauseInfo = null;
+    this._stackFrames = [];
+    this.refs.clearAll();
+    this.breakpoints.clear();
+    this.allBreakpoints = [];
+    this.functionBreakpoints = [];
+    this._consoleMessages = [];
+    this._exceptionEntries = [];
+  }
+  async continue() {
+    this.requireConnected();
+    this.requirePaused();
+    const waiter = this.createStoppedWaiter(30000);
+    await this.getDap().send("continue", { threadId: this._threadId });
+    this._state = "running";
+    this._pauseInfo = null;
+    this._stackFrames = [];
+    this.refs.clearVolatile();
+    await waiter;
+    if (this.isPaused())
+      await this.fetchStackTrace();
+  }
+  async step(mode) {
+    this.requireConnected();
+    this.requirePaused();
+    const waiter = this.createStoppedWaiter(30000);
+    const command = mode === "into" ? "stepIn" : mode === "out" ? "stepOut" : "next";
+    await this.getDap().send(command, { threadId: this._threadId });
+    this._state = "running";
+    this._pauseInfo = null;
+    this.refs.clearVolatile();
+    await waiter;
+    if (this.isPaused())
+      await this.fetchStackTrace();
+  }
+  async pause() {
+    this.requireConnected();
+    if (this._state !== "running") {
+      throw new Error("Cannot pause: target is not running");
+    }
+    const waiter = this.createStoppedWaiter(5000);
+    await this.getDap().send("pause", { threadId: this._threadId });
+    await waiter;
+    if (this.isPaused())
+      await this.fetchStackTrace();
+  }
+  async setBreakpoint(file, line, options) {
+    this.requireConnected();
+    const entry = {
+      ref: "",
+      file,
+      line,
+      condition: options?.condition,
+      hitCondition: options?.hitCount ? String(options.hitCount) : undefined,
+      verified: false
+    };
+    let fileBreakpoints = this.breakpoints.get(file);
+    if (!fileBreakpoints) {
+      fileBreakpoints = [];
+      this.breakpoints.set(file, fileBreakpoints);
+    }
+    fileBreakpoints.push(entry);
+    this.allBreakpoints.push(entry);
+    const ref = this.refs.addBreakpoint(`dap-bp:${file}:${line}`, {
+      file,
+      line
+    });
+    entry.ref = ref;
+    await this.syncFileBreakpoints(file);
+    return {
+      ref,
+      location: { url: file, line: entry.actualLine ?? line }
+    };
+  }
+  async removeBreakpoint(ref) {
+    this.requireConnected();
+    const entry = this.allBreakpoints.find((bp) => bp.ref === ref);
+    if (!entry) {
+      throw new Error(`Unknown breakpoint ref: ${ref}`);
+    }
+    const fileBreakpoints = this.breakpoints.get(entry.file);
+    if (fileBreakpoints) {
+      const idx = fileBreakpoints.indexOf(entry);
+      if (idx !== -1)
+        fileBreakpoints.splice(idx, 1);
+      if (fileBreakpoints.length === 0) {
+        this.breakpoints.delete(entry.file);
+      }
+    }
+    const allIdx = this.allBreakpoints.indexOf(entry);
+    if (allIdx !== -1)
+      this.allBreakpoints.splice(allIdx, 1);
+    this.refs.remove(ref);
+    await this.syncFileBreakpoints(entry.file);
+  }
+  async removeAllBreakpoints() {
+    this.requireConnected();
+    const files = [...this.breakpoints.keys()];
+    this.breakpoints.clear();
+    this.allBreakpoints = [];
+    this.functionBreakpoints = [];
+    for (const entry of this.refs.list("BP")) {
+      this.refs.remove(entry.ref);
+    }
+    for (const file of files) {
+      await this.getDap().send("setBreakpoints", {
+        source: { path: file },
+        breakpoints: []
+      });
+    }
+    await this.getDap().send("setFunctionBreakpoints", { breakpoints: [] });
+  }
+  listBreakpoints() {
+    const fileBps = this.allBreakpoints.map((bp) => ({
+      ref: bp.ref,
+      type: "BP",
+      url: bp.file,
+      line: bp.actualLine ?? bp.line,
+      condition: bp.condition
+    }));
+    const fnBps = this.functionBreakpoints.map((bp) => ({
+      ref: bp.ref,
+      type: "BP",
+      url: bp.name,
+      line: 0,
+      condition: bp.condition
+    }));
+    return [...fileBps, ...fnBps];
+  }
+  async setFunctionBreakpoint(name, options) {
+    this.requireConnected();
+    const entry = {
+      ref: "",
+      name,
+      condition: options?.condition,
+      hitCondition: options?.hitCount ? String(options.hitCount) : undefined,
+      verified: false
+    };
+    this.functionBreakpoints.push(entry);
+    const ref = this.refs.addBreakpoint(`dap-fn:${name}`, {
+      file: name,
+      line: 0
+    });
+    entry.ref = ref;
+    await this.syncFunctionBreakpoints();
+    return { ref };
+  }
+  async removeFunctionBreakpoint(ref) {
+    this.requireConnected();
+    const idx = this.functionBreakpoints.findIndex((bp) => bp.ref === ref);
+    if (idx === -1) {
+      throw new Error(`Unknown function breakpoint ref: ${ref}`);
+    }
+    this.functionBreakpoints.splice(idx, 1);
+    this.refs.remove(ref);
+    await this.syncFunctionBreakpoints();
+  }
+  async syncFunctionBreakpoints() {
+    const dapBps = this.functionBreakpoints.map((bp) => ({
+      name: bp.name,
+      condition: bp.condition,
+      hitCondition: bp.hitCondition
+    }));
+    const response = await this.getDap().send("setFunctionBreakpoints", {
+      breakpoints: dapBps
+    });
+    const body = response.body;
+    const resultBps = body?.breakpoints ?? [];
+    for (let i = 0;i < this.functionBreakpoints.length; i++) {
+      const entry = this.functionBreakpoints[i];
+      const result = resultBps[i];
+      if (entry && result) {
+        entry.verified = result.verified ?? false;
+      }
+    }
+  }
+  async eval(expression, options = {}) {
+    this.requireConnected();
+    this.requirePaused();
+    await this.ensureStack();
+    const frameId = this.resolveFrameId(options.frame);
+    const response = await this.getDap().send("evaluate", {
+      expression,
+      frameId,
+      context: "repl"
+    });
+    const body = response.body;
+    const remoteId = body.variablesReference > 0 ? String(body.variablesReference) : `eval:${Date.now()}`;
+    const ref = this.refs.addVar(remoteId, expression);
+    return {
+      ref,
+      type: body.type ?? "unknown",
+      value: body.result,
+      objectId: body.variablesReference > 0 ? String(body.variablesReference) : undefined
+    };
+  }
+  async getVars(options = {}) {
+    this.requireConnected();
+    this.requirePaused();
+    await this.ensureStack();
+    const frameId = this.resolveFrameId(options.frame);
+    const scopesResponse = await this.getDap().send("scopes", { frameId });
+    const scopes = scopesResponse.body.scopes;
+    const result = [];
+    const scopesToFetch = options.allScopes ? scopes : scopes.filter((s) => !s.expensive).slice(0, 2);
+    for (const scope of scopesToFetch) {
+      const varsResponse = await this.getDap().send("variables", {
+        variablesReference: scope.variablesReference
+      });
+      const variables = varsResponse.body.variables;
+      for (const v of variables) {
+        if (options.names && !options.names.includes(v.name))
+          continue;
+        const remoteId = v.variablesReference > 0 ? String(v.variablesReference) : `var:${v.name}:${Date.now()}`;
+        const ref = this.refs.addVar(remoteId, v.name);
+        result.push({
+          ref,
+          name: v.name,
+          type: v.type ?? "unknown",
+          value: v.value
+        });
+      }
+    }
+    return result;
+  }
+  async getProps(ref, _options = {}) {
+    this.requireConnected();
+    const remoteId = this.refs.resolveId(ref);
+    if (!remoteId) {
+      throw new Error(`Unknown ref: ${ref}`);
+    }
+    const variablesReference = parseInt(remoteId, 10);
+    if (Number.isNaN(variablesReference) || variablesReference <= 0) {
+      return [];
+    }
+    const response = await this.getDap().send("variables", { variablesReference });
+    const variables = response.body.variables;
+    return variables.map((v) => {
+      const childRemoteId = v.variablesReference > 0 ? String(v.variablesReference) : `prop:${v.name}:${Date.now()}`;
+      const childRef = v.variablesReference > 0 ? this.refs.addVar(childRemoteId, v.name) : undefined;
+      return {
+        ref: childRef,
+        name: v.name,
+        type: v.type ?? "unknown",
+        value: v.value,
+        isOwn: true
+      };
+    });
+  }
+  getStack(_options = {}) {
+    return this._stackFrames.map((frame) => {
+      const ref = this.refs.addFrame(String(frame.id), frame.name);
+      return {
+        ref,
+        functionName: frame.name,
+        file: frame.file ?? "<unknown>",
+        line: frame.line,
+        column: frame.column > 0 ? frame.column : undefined
+      };
+    });
+  }
+  async getSource(options = {}) {
+    const file = options.file ?? this._pauseInfo?.url;
+    if (!file) {
+      throw new Error("No source file available. Specify a file path.");
+    }
+    let content;
+    try {
+      content = await Bun.file(file).text();
+    } catch {
+      throw new Error(`Cannot read source file: ${file}`);
+    }
+    const allLines = content.split(`
+`);
+    const currentLine = this._pauseInfo?.line;
+    const windowSize = options.lines ?? 10;
+    let startLine;
+    let endLine;
+    if (options.all) {
+      startLine = 1;
+      endLine = allLines.length;
+    } else if (currentLine !== undefined) {
+      startLine = Math.max(1, currentLine - windowSize);
+      endLine = Math.min(allLines.length, currentLine + windowSize);
+    } else {
+      startLine = 1;
+      endLine = Math.min(allLines.length, windowSize * 2);
+    }
+    const lines = [];
+    for (let i = startLine;i <= endLine; i++) {
+      const lineObj = {
+        line: i,
+        text: allLines[i - 1] ?? ""
+      };
+      if (currentLine !== undefined && i === currentLine) {
+        lineObj.current = true;
+      }
+      lines.push(lineObj);
+    }
+    return { url: file, lines };
+  }
+  async buildState(options = {}) {
+    if (this.isPaused())
+      await this.ensureStack();
+    const snapshot = {
+      status: this._state
+    };
+    if (this._state === "paused" && this._pauseInfo) {
+      snapshot.reason = this._pauseInfo.reason;
+      if (this._pauseInfo.url && this._pauseInfo.line !== undefined) {
+        snapshot.location = {
+          url: this._pauseInfo.url,
+          line: this._pauseInfo.line,
+          column: this._pauseInfo.column
+        };
+      }
+    }
+    if (this._state === "paused" && options.code !== false) {
+      try {
+        const source = await this.getSource({ lines: options.lines });
+        snapshot.source = source;
+      } catch {}
+    }
+    if (this._state === "paused" && (options.vars !== false || !options.compact)) {
+      try {
+        const vars = await this.getVars({ frame: options.frame, allScopes: options.allScopes });
+        snapshot.vars = vars.map((v) => ({
+          ref: v.ref,
+          name: v.name,
+          value: v.value,
+          scope: "local"
+        }));
+      } catch {}
+    }
+    if (this._state === "paused" && options.stack !== false) {
+      try {
+        snapshot.stack = this.getStack();
+      } catch {}
+    }
+    if (options.breakpoints !== false) {
+      snapshot.breakpointCount = this.allBreakpoints.length;
+    }
+    return snapshot;
+  }
+  getConsoleMessages(options = {}) {
+    let msgs = this._consoleMessages;
+    if (options.level) {
+      msgs = msgs.filter((m) => m.level === options.level);
+    }
+    if (options.since !== undefined) {
+      const since = options.since;
+      msgs = msgs.filter((m) => m.timestamp >= since);
+    }
+    if (options.clear) {
+      this._consoleMessages = [];
+    }
+    return msgs;
+  }
+  getExceptions(options = {}) {
+    let entries = this._exceptionEntries;
+    if (options.since !== undefined) {
+      const since = options.since;
+      entries = entries.filter((e) => e.timestamp >= since);
+    }
+    return entries;
+  }
+  async setLogpoint(_file, _line, _template, _options) {
+    throw new Error("Logpoints are not supported in DAP mode. Use breakpoints with conditions instead.");
+  }
+  async setExceptionPause(mode) {
+    this.requireConnected();
+    const available = this.capabilities.exceptionBreakpointFilters ?? [];
+    const filterIds = available.map((f) => f.filter);
+    let filters;
+    if (mode === "none") {
+      filters = [];
+    } else if (mode === "all") {
+      filters = filterIds;
+    } else {
+      filters = filterIds.filter((id) => id.includes(mode));
+      if (filters.length === 0)
+        filters = filterIds;
+    }
+    await this.getDap().send("setExceptionBreakpoints", { filters });
+  }
+  async toggleBreakpoint(_ref) {
+    throw new Error("Breakpoint toggling is not yet supported in DAP mode. Use break-rm and break.");
+  }
+  async getBreakableLocations(_file, _startLine, _endLine) {
+    throw new Error("Breakable locations are not supported in DAP mode.");
+  }
+  async hotpatch(_file, _source, _options) {
+    throw new Error("Hot-patching is not supported in DAP mode.");
+  }
+  async searchInScripts(_query, _options) {
+    throw new Error("Script search is not supported in DAP mode. Use your shell to search source files.");
+  }
+  async setVariable(varName, value, options = {}) {
+    this.requireConnected();
+    this.requirePaused();
+    await this.ensureStack();
+    const frameId = this.resolveFrameId(options.frame);
+    const scopesResponse = await this.getDap().send("scopes", { frameId });
+    const scopes = scopesResponse.body.scopes;
+    for (const scope of scopes) {
+      try {
+        const response = await this.getDap().send("setVariable", {
+          variablesReference: scope.variablesReference,
+          name: varName,
+          value
+        });
+        const body = response.body;
+        return { name: varName, newValue: body.value, type: body.type ?? "unknown" };
+      } catch {}
+    }
+    throw new Error(`Variable "${varName}" not found in any scope`);
+  }
+  async setReturnValue(_value) {
+    throw new Error("Setting return values is not supported in DAP mode.");
+  }
+  async restartFrame(_frameRef) {
+    throw new Error("Frame restart is not supported in DAP mode.");
+  }
+  async runTo(_file, _line) {
+    throw new Error("Run-to-location is not yet supported in DAP mode. Set a breakpoint and continue.");
+  }
+  getScripts(_filter) {
+    return [];
+  }
+  async addBlackbox(_patterns) {
+    throw new Error("Blackboxing is not supported in DAP mode.");
+  }
+  listBlackbox() {
+    return [];
+  }
+  async removeBlackbox(_patterns) {
+    throw new Error("Blackboxing is not supported in DAP mode.");
+  }
+  async restart() {
+    throw new Error("Restart is not yet supported in DAP mode. Use stop + launch.");
+  }
+  get sourceMapResolver() {
+    return {
+      findScriptForSource: () => null,
+      getInfo: () => null,
+      getAllInfos: () => [],
+      setDisabled: () => {}
+    };
+  }
+  isPaused() {
+    return this._state === "paused";
+  }
+  async ensureStack() {
+    if (this.isPaused() && this._stackFrames.length === 0) {
+      await this.fetchStackTrace();
+    }
+  }
+  getDap() {
+    if (!this.dap || !this.dap.connected) {
+      throw new Error("Not connected to a debug adapter. Use launch or attach first.");
+    }
+    return this.dap;
+  }
+  requireConnected() {
+    this.getDap();
+  }
+  requirePaused() {
+    if (!this.isPaused()) {
+      throw new Error("Target is not paused. Use pause or wait for a breakpoint.");
+    }
+  }
+  async initializeAdapter() {
+    const response = await this.getDap().send("initialize", {
+      adapterID: this._runtime,
+      clientID: "agent-dbg",
+      clientName: "agent-dbg",
+      linesStartAt1: true,
+      columnsStartAt1: true,
+      pathFormat: "path",
+      supportsVariableType: true
+    });
+    this.capabilities = response.body ?? {};
+  }
+  setupEventHandlers() {
+    const dap = this.getDap();
+    dap.on("stopped", (body) => {
+      const event = body;
+      this._state = "paused";
+      if (event.threadId !== undefined) {
+        this._threadId = event.threadId;
+      }
+      this._pauseInfo = {
+        reason: event.reason
+      };
+      if (this.stoppedWaiter) {
+        this.stoppedWaiter.resolve();
+        this.stoppedWaiter = null;
+      } else {
+        this.fetchStackTrace().catch(() => {});
+      }
+    });
+    dap.on("continued", (_body) => {
+      this._state = "running";
+      this._pauseInfo = null;
+      this._stackFrames = [];
+      this.refs.clearVolatile();
+    });
+    dap.on("terminated", (_body) => {
+      this._state = "idle";
+      this._pauseInfo = null;
+      this._stackFrames = [];
+      this.stoppedWaiter?.resolve();
+      this.stoppedWaiter = null;
+    });
+    dap.on("exited", (_body) => {
+      this._state = "idle";
+      this._pauseInfo = null;
+      this.stoppedWaiter?.resolve();
+      this.stoppedWaiter = null;
+    });
+    dap.on("output", (body) => {
+      const event = body;
+      const category = event.category ?? "console";
+      if (category === "stdout" || category === "console") {
+        this._consoleMessages.push({
+          timestamp: Date.now(),
+          level: "log",
+          text: event.output.trimEnd(),
+          url: event.source?.path,
+          line: event.line
+        });
+      } else if (category === "stderr") {
+        this._consoleMessages.push({
+          timestamp: Date.now(),
+          level: "error",
+          text: event.output.trimEnd(),
+          url: event.source?.path,
+          line: event.line
+        });
+      }
+      if (this._consoleMessages.length > 1000) {
+        this._consoleMessages.shift();
+      }
+    });
+  }
+  async fetchStackTrace() {
+    if (this._stackFetchPromise) {
+      await this._stackFetchPromise;
+      return;
+    }
+    this._stackFetchPromise = this._fetchStackTraceImpl();
+    try {
+      await this._stackFetchPromise;
+    } finally {
+      this._stackFetchPromise = null;
+    }
+  }
+  async _fetchStackTraceImpl() {
+    if (!this.dap || this._state !== "paused")
+      return;
+    try {
+      const response = await this.dap.send("stackTrace", {
+        threadId: this._threadId,
+        startFrame: 0,
+        levels: 50
+      });
+      const body = response.body;
+      this._stackFrames = body.stackFrames.map((f) => ({
+        id: f.id,
+        name: f.name,
+        file: f.source?.path ?? f.source?.name,
+        line: f.line,
+        column: f.column
+      }));
+      const topFrame = this._stackFrames[0];
+      if (topFrame && this._pauseInfo) {
+        this._pauseInfo.url = topFrame.file;
+        this._pauseInfo.line = topFrame.line;
+        this._pauseInfo.column = topFrame.column > 0 ? topFrame.column : undefined;
+        this._pauseInfo.callFrameCount = this._stackFrames.length;
+      }
+    } catch {}
+  }
+  resolveFrameId(frameRef) {
+    if (!frameRef) {
+      const topFrame = this._stackFrames[0];
+      if (!topFrame) {
+        throw new Error("No stack frames available");
+      }
+      return topFrame.id;
+    }
+    const remoteId = this.refs.resolveId(frameRef);
+    if (!remoteId) {
+      throw new Error(`Unknown frame ref: ${frameRef}`);
+    }
+    return parseInt(remoteId, 10);
+  }
+  async syncFileBreakpoints(file) {
+    const entries = this.breakpoints.get(file) ?? [];
+    const dapBreakpoints = entries.map((bp) => {
+      const sbp = { line: bp.line };
+      if (bp.condition)
+        sbp.condition = bp.condition;
+      if (bp.hitCondition)
+        sbp.hitCondition = bp.hitCondition;
+      return sbp;
+    });
+    const response = await this.getDap().send("setBreakpoints", {
+      source: { path: file },
+      breakpoints: dapBreakpoints
+    });
+    const body = response.body;
+    for (let i = 0;i < entries.length && i < body.breakpoints.length; i++) {
+      const bp = body.breakpoints[i];
+      const entry = entries[i];
+      if (bp && entry) {
+        entry.dapId = bp.id;
+        entry.verified = bp.verified;
+        entry.actualLine = bp.line ?? entry.line;
+      }
+    }
+  }
+  createStoppedWaiter(timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.stoppedWaiter = null;
+        resolve();
+      }, timeoutMs);
+      this.stoppedWaiter = {
+        resolve: () => {
+          clearTimeout(timer);
+          this.stoppedWaiter = null;
+          resolve();
+        },
+        reject: (e) => {
+          clearTimeout(timer);
+          this.stoppedWaiter = null;
+          reject(e);
+        }
+      };
+    });
+  }
+  async waitForStop(timeoutMs) {
+    if (!this.isPaused()) {
+      await this.createStoppedWaiter(timeoutMs);
+    }
+    if (this.isPaused() && this._stackFrames.length === 0) {
+      await this.fetchStackTrace();
+    }
+  }
+}
+var init_session = __esm(() => {
+  init_ref_table();
+});
+
+// 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 _ {
@@ -6035,7 +7144,7 @@ var init_esm2 = __esm(() => {
 });
 
 // src/protocol/messages.ts
-var PingRequest, LaunchRequest, AttachRequest, StatusRequest, StateRequest, ContinueRequest, StepRequest, PauseRequest, RunToRequest, BreakRequest, BreakRmRequest, BreakLsRequest, LogpointRequest, CatchRequest, SourceRequest, ScriptsRequest, StackRequest, SearchRequest, ConsoleRequest, ExceptionsRequest, EvalRequest, VarsRequest, PropsRequest, BlackboxRequest, BlackboxLsRequest, BlackboxRmRequest, SetRequest, SetReturnRequest, HotpatchRequest, BreakToggleRequest, BreakableRequest, RestartFrameRequest, SourcemapRequest, SourcemapDisableRequest, RestartRequest, StopRequest, DaemonRequestSchema, SuccessResponse, ErrorResponse, DaemonResponseSchema;
+var PingRequest, LaunchRequest, AttachRequest, StatusRequest, StateRequest, ContinueRequest, StepRequest, PauseRequest, RunToRequest, BreakRequest, BreakFnRequest, BreakRmRequest, BreakLsRequest, LogpointRequest, CatchRequest, SourceRequest, ScriptsRequest, StackRequest, SearchRequest, ConsoleRequest, ExceptionsRequest, EvalRequest, VarsRequest, PropsRequest, BlackboxRequest, BlackboxLsRequest, BlackboxRmRequest, SetRequest, SetReturnRequest, HotpatchRequest, BreakToggleRequest, BreakableRequest, RestartFrameRequest, SourcemapRequest, SourcemapDisableRequest, RestartRequest, StopRequest, DaemonRequestSchema, SuccessResponse, ErrorResponse, DaemonResponseSchema;
 var init_messages = __esm(() => {
   init_esm2();
   PingRequest = exports_external.object({ cmd: exports_external.literal("ping") });
@@ -6044,13 +7153,15 @@ var init_messages = __esm(() => {
     args: exports_external.object({
       command: exports_external.array(exports_external.string()),
       brk: exports_external.optional(exports_external.boolean()),
-      port: exports_external.optional(exports_external.number())
+      port: exports_external.optional(exports_external.number()),
+      runtime: exports_external.optional(exports_external.string())
     })
   });
   AttachRequest = exports_external.object({
     cmd: exports_external.literal("attach"),
     args: exports_external.object({
-      target: exports_external.string()
+      target: exports_external.string(),
+      runtime: exports_external.optional(exports_external.string())
     })
   });
   StatusRequest = exports_external.object({ cmd: exports_external.literal("status") });
@@ -6091,7 +7202,15 @@ var init_messages = __esm(() => {
       line: exports_external.number(),
       condition: exports_external.optional(exports_external.string()),
       hitCount: exports_external.optional(exports_external.number()),
-      urlRegex: exports_external.optional(exports_external.string())
+      urlRegex: exports_external.optional(exports_external.string()),
+      column: exports_external.optional(exports_external.number())
+    })
+  });
+  BreakFnRequest = exports_external.object({
+    cmd: exports_external.literal("break-fn"),
+    args: exports_external.object({
+      name: exports_external.string(),
+      condition: exports_external.optional(exports_external.string())
     })
   });
   BreakRmRequest = exports_external.object({
@@ -6269,6 +7388,7 @@ var init_messages = __esm(() => {
     PauseRequest,
     RunToRequest,
     BreakRequest,
+    BreakFnRequest,
     BreakRmRequest,
     BreakLsRequest,
     LogpointRequest,
@@ -6308,36 +7428,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 +7439,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,13 +7462,13 @@ 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,
       socket: {
         open(socket) {
-          socket.data = { buffer: "" };
+          socket.data = { buffer: "", pendingWrite: null, pendingOffset: 0 };
           server.resetIdleTimer();
         },
         data(socket, data) {
@@ -6387,68 +7481,81 @@ class DaemonServer {
           socket.data.buffer = socket.data.buffer.slice(newlineIdx + 1);
           server.handleMessage(socket, line);
         },
+        drain(socket) {
+          server.flushPending(socket);
+        },
         close() {},
         error(_socket, error3) {
+          server.logger?.error("socket.error", error3.message);
           console.error(`[daemon] socket error: ${error3.message}`);
         }
       }
     });
     this.resetIdleTimer();
   }
+  flushPending(socket) {
+    const data = socket.data;
+    if (!data.pendingWrite)
+      return;
+    while (data.pendingOffset < data.pendingWrite.length) {
+      const written = socket.write(data.pendingWrite.subarray(data.pendingOffset));
+      if (written === 0) {
+        return;
+      }
+      data.pendingOffset += written;
+    }
+    data.pendingWrite = null;
+    data.pendingOffset = 0;
+    socket.end();
+  }
+  sendResponse(socket, response) {
+    const payload = Buffer.from(`${JSON.stringify(response)}
+`);
+    const written = socket.write(payload);
+    if (written < payload.length) {
+      socket.data.pendingWrite = payload;
+      socket.data.pendingOffset = written;
+    } else {
+      socket.end();
+    }
+  }
   handleMessage(socket, line) {
     let json2;
     try {
       json2 = JSON.parse(line);
     } catch {
-      const errResponse = {
-        ok: false,
-        error: "Invalid JSON"
-      };
-      socket.write(`${JSON.stringify(errResponse)}
-`);
-      socket.end();
+      this.sendResponse(socket, { ok: false, error: "Invalid JSON" });
       return;
     }
     const parsed = DaemonRequestSchema.safeParse(json2);
     if (!parsed.success) {
       const obj = json2;
       const cmd = obj && typeof obj === "object" && typeof obj.cmd === "string" ? obj.cmd : undefined;
-      const errResponse = cmd ? {
+      this.sendResponse(socket, cmd ? {
         ok: false,
         error: `Unknown command: ${cmd}`,
         suggestion: "-> Try: agent-dbg --help"
       } : {
         ok: false,
         error: "Invalid request: must have { cmd: string, args: object }"
-      };
-      socket.write(`${JSON.stringify(errResponse)}
-`);
-      socket.end();
+      });
       return;
     }
     const request = parsed.data;
     if (!this.handler) {
-      const errResponse = {
+      this.sendResponse(socket, {
         ok: false,
         error: "No request handler registered"
-      };
-      socket.write(`${JSON.stringify(errResponse)}
-`);
-      socket.end();
+      });
       return;
     }
     this.handler(request).then((response) => {
-      socket.write(`${JSON.stringify(response)}
-`);
-      socket.end();
+      this.sendResponse(socket, response);
     }).catch((err) => {
-      const errResponse = {
+      this.sendResponse(socket, {
         ok: false,
         error: err instanceof Error ? err.message : String(err)
-      };
-      socket.write(`${JSON.stringify(errResponse)}
-`);
-      socket.end();
+      });
     });
   }
   resetIdleTimer() {
@@ -6457,6 +7564,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);
     }
@@ -6540,7 +7648,7 @@ class CdpClient {
         this.pending.delete(id);
         this.sentMethods.delete(id);
         reject(new Error(`CDP request timed out: ${method} (id=${id})`));
-      }, DEFAULT_TIMEOUT_MS);
+      }, DEFAULT_TIMEOUT_MS2);
       this.pending.set(id, { resolve, reject, timer });
       this.ws.send(JSON.stringify(request));
     });
@@ -6644,17 +7752,17 @@ class CdpClient {
     }
   }
 }
-var DEFAULT_TIMEOUT_MS = 30000;
+var DEFAULT_TIMEOUT_MS2 = 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 +7795,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) {
@@ -6901,101 +8009,6 @@ function formatValue(obj, maxLen = 80) {
   return truncate(obj.description ?? String(obj.value ?? obj.type), maxLen);
 }
 
-// src/refs/ref-table.ts
-class RefTable {
-  entries = new Map;
-  counters = {
-    v: 1,
-    f: 0,
-    o: 1,
-    BP: 1,
-    LP: 1,
-    HS: 1
-  };
-  addVar(remoteId, name, meta) {
-    return this.add("v", remoteId, name, meta);
-  }
-  addFrame(remoteId, name, meta) {
-    return this.add("f", remoteId, name, meta);
-  }
-  addObject(remoteId, name, meta) {
-    return this.add("o", remoteId, name, meta);
-  }
-  addBreakpoint(remoteId, meta) {
-    return this.add("BP", remoteId, undefined, meta);
-  }
-  addLogpoint(remoteId, meta) {
-    return this.add("LP", remoteId, undefined, meta);
-  }
-  addHeapSnapshot(remoteId, meta) {
-    return this.add("HS", remoteId, undefined, meta);
-  }
-  resolve(ref) {
-    return this.entries.get(ref);
-  }
-  resolveId(ref) {
-    return this.entries.get(ref)?.remoteId;
-  }
-  clearVolatile() {
-    for (const [key, entry] of this.entries) {
-      if (entry.type === "v" || entry.type === "f") {
-        this.entries.delete(key);
-      }
-    }
-    this.counters.v = 1;
-    this.counters.f = 0;
-  }
-  clearObjects() {
-    for (const [key, entry] of this.entries) {
-      if (entry.type === "o") {
-        this.entries.delete(key);
-      }
-    }
-    this.counters.o = 1;
-  }
-  clearAll() {
-    this.entries.clear();
-    this.counters = { v: 1, f: 0, o: 1, BP: 1, LP: 1, HS: 1 };
-  }
-  list(type) {
-    const result = [];
-    for (const entry of this.entries.values()) {
-      if (entry.type === type) {
-        result.push(entry);
-      }
-    }
-    return result;
-  }
-  remove(ref) {
-    return this.entries.delete(ref);
-  }
-  add(type, remoteId, name, meta) {
-    const num = this.counters[type];
-    this.counters[type] = num + 1;
-    const ref = `${PREFIXES[type]}${num}`;
-    const entry = { ref, type, remoteId };
-    if (name !== undefined) {
-      entry.name = name;
-    }
-    if (meta !== undefined) {
-      entry.meta = meta;
-    }
-    this.entries.set(ref, entry);
-    return ref;
-  }
-}
-var PREFIXES;
-var init_ref_table = __esm(() => {
-  PREFIXES = {
-    v: "@v",
-    f: "@f",
-    o: "@o",
-    BP: "BP#",
-    LP: "LP#",
-    HS: "HS#"
-  };
-});
-
 // node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
 function decodeInteger(reader, relative) {
   let value = 0;
@@ -8819,7 +9832,8 @@ async function hotpatch(session, file2, newSource, options = {}) {
   }
   const setSourceParams = {
     scriptId,
-    scriptSource: newSource
+    scriptSource: newSource,
+    allowTopFrameEditing: true
   };
   if (options.dryRun) {
     setSourceParams.dryRun = true;
@@ -9040,10 +10054,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 +10078,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 +10405,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 +10515,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 +10528,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 +10550,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 +10590,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();
+var init_session2 = __esm(() => {
+  init_logger2();
   init_ref_table();
   init_resolver();
+  init_logger();
   init_paths();
   init_session_inspection();
   init_session_mutation();
@@ -9567,10 +10615,19 @@ var init_session = __esm(() => {
 
 // src/daemon/entry.ts
 var exports_entry = {};
-var daemonIdx, session, timeout = 300, timeoutIdx, server, debugSession;
+function isDapRuntime(runtime) {
+  return runtime !== undefined && runtime !== "node";
+}
+function activeSession() {
+  return dapSession ?? cdpSession;
+}
+var daemonIdx, session, timeout = 300, timeoutIdx, daemonLogger, server, cdpSession, dapSession = null;
 var init_entry = __esm(async () => {
-  init_server();
   init_session();
+  init_logger();
+  init_paths();
+  init_server();
+  init_session2();
   daemonIdx = process.argv.indexOf("--daemon");
   session = daemonIdx !== -1 ? process.argv[daemonIdx + 1] : process.argv[2];
   if (!session) {
@@ -9587,53 +10644,70 @@ 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 });
+  cdpSession = new DebugSession(session, { daemonLogger });
   server.onRequest(async (req) => {
     switch (req.cmd) {
       case "ping":
         return { ok: true, data: "pong" };
       case "launch": {
-        const { command, brk = true, port } = req.args;
-        const result = await debugSession.launch(command, { brk, port });
+        const { command, brk = true, port, runtime } = req.args;
+        if (isDapRuntime(runtime)) {
+          dapSession = new DapSession(session, runtime);
+          const result2 = await dapSession.launch(command, { brk });
+          return { ok: true, data: result2 };
+        }
+        const result = await cdpSession.launch(command, { brk, port });
         return { ok: true, data: result };
       }
       case "attach": {
-        const { target } = req.args;
-        const result = await debugSession.attach(target);
+        const { target, runtime } = req.args;
+        if (isDapRuntime(runtime)) {
+          dapSession = new DapSession(session, runtime);
+          const result2 = await dapSession.attach(target);
+          return { ok: true, data: result2 };
+        }
+        const result = await cdpSession.attach(target);
         return { ok: true, data: result };
       }
       case "status":
-        return { ok: true, data: debugSession.getStatus() };
+        return { ok: true, data: activeSession().getStatus() };
       case "state": {
-        const stateResult = await debugSession.buildState(req.args);
+        const stateResult = await activeSession().buildState(req.args);
         return { ok: true, data: stateResult };
       }
       case "continue": {
-        await debugSession.continue();
-        const stateAfter = await debugSession.buildState();
+        await activeSession().continue();
+        const stateAfter = await activeSession().buildState();
         return { ok: true, data: stateAfter };
       }
       case "step": {
         const { mode = "over" } = req.args;
-        await debugSession.step(mode);
-        const stateAfter = await debugSession.buildState();
+        await activeSession().step(mode);
+        const stateAfter = await activeSession().buildState();
         return { ok: true, data: stateAfter };
       }
       case "pause": {
-        await debugSession.pause();
-        const stateAfter = await debugSession.buildState();
+        await activeSession().pause();
+        const stateAfter = await activeSession().buildState();
         return { ok: true, data: stateAfter };
       }
       case "run-to": {
         const { file: file2, line } = req.args;
-        await debugSession.runTo(file2, line);
-        const stateAfter = await debugSession.buildState();
+        await activeSession().runTo(file2, line);
+        const stateAfter = await activeSession().buildState();
         return { ok: true, data: stateAfter };
       }
       case "break": {
         const { file: file2, line, condition, hitCount, urlRegex: urlRegex2, column } = req.args;
-        const bpResult = await debugSession.setBreakpoint(file2, line, {
+        const bpResult = await activeSession().setBreakpoint(file2, line, {
           condition,
           hitCount,
           urlRegex: urlRegex2,
@@ -9641,20 +10715,35 @@ var init_entry = __esm(async () => {
         });
         return { ok: true, data: bpResult };
       }
+      case "break-fn": {
+        const session2 = activeSession();
+        if (!("setFunctionBreakpoint" in session2)) {
+          return {
+            ok: false,
+            error: "Function breakpoints are only supported with DAP runtimes (e.g. --runtime lldb)",
+            suggestion: "Use 'break <file>:<line>' for CDP sessions"
+          };
+        }
+        const { name, condition } = req.args;
+        const bpResult = await session2.setFunctionBreakpoint(name, {
+          condition
+        });
+        return { ok: true, data: bpResult };
+      }
       case "break-rm": {
         const { ref } = req.args;
         if (ref === "all") {
-          await debugSession.removeAllBreakpoints();
+          await activeSession().removeAllBreakpoints();
           return { ok: true, data: "all removed" };
         }
-        await debugSession.removeBreakpoint(ref);
+        await activeSession().removeBreakpoint(ref);
         return { ok: true, data: "removed" };
       }
       case "break-ls":
-        return { ok: true, data: debugSession.listBreakpoints() };
+        return { ok: true, data: activeSession().listBreakpoints() };
       case "logpoint": {
         const { file: file2, line, template, condition, maxEmissions } = req.args;
-        const lpResult = await debugSession.setLogpoint(file2, line, template, {
+        const lpResult = await activeSession().setLogpoint(file2, line, template, {
           condition,
           maxEmissions
         });
@@ -9662,114 +10751,115 @@ var init_entry = __esm(async () => {
       }
       case "catch": {
         const { mode } = req.args;
-        await debugSession.setExceptionPause(mode);
+        await activeSession().setExceptionPause(mode);
         return { ok: true, data: mode };
       }
       case "source": {
-        const sourceResult = await debugSession.getSource(req.args);
+        const sourceResult = await activeSession().getSource(req.args);
         return { ok: true, data: sourceResult };
       }
       case "scripts": {
         const { filter } = req.args;
-        const scriptsResult = debugSession.getScripts(filter);
+        const scriptsResult = activeSession().getScripts(filter);
         return { ok: true, data: scriptsResult };
       }
       case "stack": {
-        const stackResult = debugSession.getStack(req.args);
+        const stackResult = activeSession().getStack(req.args);
         return { ok: true, data: stackResult };
       }
       case "search": {
         const { query, ...searchOptions } = req.args;
-        const searchResult = await debugSession.searchInScripts(query, searchOptions);
+        const searchResult = await activeSession().searchInScripts(query, searchOptions);
         return { ok: true, data: searchResult };
       }
       case "console": {
-        const consoleResult = debugSession.getConsoleMessages(req.args);
+        const consoleResult = activeSession().getConsoleMessages(req.args);
         return { ok: true, data: consoleResult };
       }
       case "exceptions": {
-        const exceptionsResult = debugSession.getExceptions(req.args);
+        const exceptionsResult = activeSession().getExceptions(req.args);
         return { ok: true, data: exceptionsResult };
       }
       case "eval": {
         const { expression, ...evalOptions } = req.args;
-        const evalResult = await debugSession.eval(expression, evalOptions);
+        const evalResult = await activeSession().eval(expression, evalOptions);
         return { ok: true, data: evalResult };
       }
       case "vars": {
-        const varsResult = await debugSession.getVars(req.args);
+        const varsResult = await activeSession().getVars(req.args);
         return { ok: true, data: varsResult };
       }
       case "props": {
         const { ref, ...propsOptions } = req.args;
-        const propsResult = await debugSession.getProps(ref, propsOptions);
+        const propsResult = await activeSession().getProps(ref, propsOptions);
         return { ok: true, data: propsResult };
       }
       case "blackbox": {
         const { patterns } = req.args;
-        const result = await debugSession.addBlackbox(patterns);
+        const result = await activeSession().addBlackbox(patterns);
         return { ok: true, data: result };
       }
       case "blackbox-ls": {
-        return { ok: true, data: debugSession.listBlackbox() };
+        return { ok: true, data: activeSession().listBlackbox() };
       }
       case "blackbox-rm": {
         const { patterns } = req.args;
-        const result = await debugSession.removeBlackbox(patterns);
+        const result = await activeSession().removeBlackbox(patterns);
         return { ok: true, data: result };
       }
       case "set": {
         const { name, value, frame } = req.args;
-        const result = await debugSession.setVariable(name, value, { frame });
+        const result = await activeSession().setVariable(name, value, { frame });
         return { ok: true, data: result };
       }
       case "set-return": {
         const { value } = req.args;
-        const result = await debugSession.setReturnValue(value);
+        const result = await activeSession().setReturnValue(value);
         return { ok: true, data: result };
       }
       case "hotpatch": {
         const { file: file2, source, dryRun } = req.args;
-        const result = await debugSession.hotpatch(file2, source, { dryRun });
+        const result = await activeSession().hotpatch(file2, source, { dryRun });
         return { ok: true, data: result };
       }
       case "break-toggle": {
         const { ref } = req.args;
-        const toggleResult = await debugSession.toggleBreakpoint(ref);
+        const toggleResult = await activeSession().toggleBreakpoint(ref);
         return { ok: true, data: toggleResult };
       }
       case "breakable": {
         const { file: file2, startLine, endLine } = req.args;
-        const breakableResult = await debugSession.getBreakableLocations(file2, startLine, endLine);
+        const breakableResult = await activeSession().getBreakableLocations(file2, startLine, endLine);
         return { ok: true, data: breakableResult };
       }
       case "restart-frame": {
         const { frameRef } = req.args;
-        const restartResult = await debugSession.restartFrame(frameRef);
+        const restartResult = await activeSession().restartFrame(frameRef);
         return { ok: true, data: restartResult };
       }
       case "sourcemap": {
         const { file: smFile } = req.args;
         if (smFile) {
-          const match = debugSession.sourceMapResolver.findScriptForSource(smFile);
+          const match = activeSession().sourceMapResolver.findScriptForSource(smFile);
           if (match) {
-            const info = debugSession.sourceMapResolver.getInfo(match.scriptId);
+            const info = activeSession().sourceMapResolver.getInfo(match.scriptId);
             return { ok: true, data: info ? [info] : [] };
           }
           return { ok: true, data: [] };
         }
-        return { ok: true, data: debugSession.sourceMapResolver.getAllInfos() };
+        return { ok: true, data: activeSession().sourceMapResolver.getAllInfos() };
       }
       case "sourcemap-disable": {
-        debugSession.sourceMapResolver.setDisabled(true);
+        activeSession().sourceMapResolver.setDisabled(true);
         return { ok: true, data: "disabled" };
       }
       case "restart": {
-        const result = await debugSession.restart();
+        const result = await activeSession().restart();
         return { ok: true, data: result };
       }
       case "stop":
-        await debugSession.stop();
+        await activeSession().stop();
+        dapSession = null;
         setTimeout(() => {
           server.stop();
           process.exit(0);
@@ -9790,7 +10880,7 @@ var init_registry = __esm(() => {
 });
 
 // src/daemon/client.ts
-import { existsSync as existsSync3, readdirSync } from "fs";
+import { existsSync as existsSync3, readdirSync, readFileSync, unlinkSync as unlinkSync2 } from "fs";
 
 class DaemonClient {
   session;
@@ -9810,9 +10900,9 @@ class DaemonClient {
       const timer = setTimeout(() => {
         if (!settled) {
           settled = true;
-          reject(new Error(`Request timed out after ${DEFAULT_TIMEOUT_MS2}ms`));
+          reject(new Error(`Request timed out after ${DEFAULT_TIMEOUT_MS3}ms`));
         }
-      }, DEFAULT_TIMEOUT_MS2);
+      }, DEFAULT_TIMEOUT_MS3);
       Bun.connect({
         unix: socketPath,
         socket: {
@@ -9890,12 +10980,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)) {
@@ -9918,20 +11024,20 @@ class DaemonClient {
     return files.filter((f) => f.endsWith(".sock")).map((f) => f.slice(0, -5));
   }
 }
-var DEFAULT_TIMEOUT_MS2 = 30000;
+var DEFAULT_TIMEOUT_MS3 = 30000;
 var init_client = __esm(() => {
   init_messages();
   init_paths();
 });
 
 // src/daemon/spawn.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync4, openSync, readFileSync as readFileSync2 } from "fs";
 async function spawnDaemon(session2, options = {}) {
   const socketPath = getSocketPath(session2);
   const spawnArgs = [];
   const execPath = process.execPath;
   const scriptPath = process.argv[1];
-  if (scriptPath && scriptPath.endsWith(".ts")) {
+  if (scriptPath && (scriptPath.endsWith(".ts") || scriptPath.endsWith(".js"))) {
     spawnArgs.push(execPath, "run", scriptPath);
   } else {
     spawnArgs.push(execPath);
@@ -9940,11 +11046,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;
@@ -9954,10 +11062,34 @@ async function spawnDaemon(session2, options = {}) {
     }
     await Bun.sleep(POLL_INTERVAL_MS);
   }
-  throw new Error(`Daemon for session "${session2}" failed to start within ${SPAWN_TIMEOUT_MS}ms`);
+  const logPath = getDaemonLogPath(session2);
+  let logTail = "";
+  try {
+    const log = readFileSync2(logPath, "utf-8");
+    const lines = log.trimEnd().split(`
+`);
+    logTail = lines.slice(-20).join(`
+`);
+  } catch {}
+  const details = [
+    `Daemon for session "${session2}" failed to start within ${SPAWN_TIMEOUT_MS}ms`,
+    `Spawn command: ${spawnArgs.join(" ")}`,
+    `Socket path: ${socketPath}`,
+    logTail ? `Daemon log (last 20 lines):
+${logTail}` : `No daemon log at ${logPath}`
+  ].join(`
+`);
+  throw new Error(details);
+}
+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();
 });
 
@@ -9995,17 +11127,16 @@ var init_launch = __esm(() => {
     const brk = args.flags.brk === true;
     const port = typeof args.flags.port === "string" ? parseInt(args.flags.port, 10) : undefined;
     const timeout2 = typeof args.flags.timeout === "string" ? parseInt(args.flags.timeout, 10) : undefined;
+    const runtime = typeof args.flags.runtime === "string" ? args.flags.runtime : undefined;
     const command = args.subcommand ? [args.subcommand, ...args.positionals] : [...args.positionals];
     if (command.length === 0) {
       console.error("No command specified");
       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 });
+    const response = await client.request("launch", { command, brk, port, runtime });
     if (!response.ok) {
       console.error(`${response.error}`);
       if (response.suggestion)
@@ -10038,6 +11169,7 @@ var init_attach = __esm(() => {
   registerCommand("attach", async (args) => {
     const session2 = args.global.session;
     const target = args.subcommand ?? args.positionals[0];
+    const runtime = typeof args.flags.runtime === "string" ? args.flags.runtime : undefined;
     if (!target) {
       console.error("No target specified");
       console.error("  -> Try: agent-dbg attach <ws-url | port>");
@@ -10049,9 +11181,9 @@ 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 });
+    const response = await client.request("attach", { target, runtime });
     if (!response.ok) {
       console.error(`${response.error}`);
       if (response.suggestion)
@@ -10811,6 +11943,44 @@ var init_break = __esm(() => {
   });
 });
 
+// src/commands/break-fn.ts
+var exports_break_fn = {};
+var init_break_fn = __esm(() => {
+  init_registry();
+  init_client();
+  registerCommand("break-fn", async (args) => {
+    const session2 = args.global.session;
+    if (!DaemonClient.isRunning(session2)) {
+      console.error(`No active session "${session2}"`);
+      console.error("  -> Try: agent-dbg launch --brk --runtime lldb ./program");
+      return 1;
+    }
+    const name = args.subcommand;
+    if (!name) {
+      console.error("Usage: agent-dbg break-fn <function-name>");
+      console.error("  Example: agent-dbg break-fn __assert_rtn");
+      console.error("  Example: agent-dbg break-fn 'yoga::Style::operator=='");
+      return 1;
+    }
+    const condition = typeof args.flags.condition === "string" ? args.flags.condition : undefined;
+    const client = new DaemonClient(session2);
+    const response = await client.request("break-fn", { name, condition });
+    if (!response.ok) {
+      console.error(`${response.error}`);
+      if (response.suggestion)
+        console.error(`  ${response.suggestion}`);
+      return 1;
+    }
+    const data = response.data;
+    if (args.global.json) {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(`${data.ref}  fn:${name}`);
+    }
+    return 0;
+  });
+});
+
 // src/commands/break-rm.ts
 var exports_break_rm = {};
 var init_break_rm = __esm(() => {
@@ -12006,7 +13176,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 +13239,12 @@ var init_logs = __esm(() => {
       return `breakpointId=${r.breakpointId}`;
     }
   };
+  levelColors = {
+    info: "INFO ",
+    warn: "WARN ",
+    error: "ERROR",
+    debug: "DEBUG"
+  };
 });
 
 // src/commands/logs.ts
@@ -12070,13 +13252,25 @@ var exports_logs = {};
 import {
   closeSync,
   existsSync as existsSync5,
-  openSync,
-  readFileSync,
+  openSync as openSync2,
+  readFileSync as readFileSync3,
   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 +13285,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 +13297,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 = readFileSync3(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 +13356,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, () => {
@@ -12469,6 +13692,7 @@ if (process.argv.includes("--daemon")) {
   await Promise.resolve().then(() => (init_pause(), exports_pause));
   await Promise.resolve().then(() => (init_run_to(), exports_run_to));
   await Promise.resolve().then(() => (init_break(), exports_break));
+  await Promise.resolve().then(() => (init_break_fn(), exports_break_fn));
   await Promise.resolve().then(() => (init_break_rm(), exports_break_rm));
   await Promise.resolve().then(() => (init_break_ls(), exports_break_ls));
   await Promise.resolve().then(() => (init_logpoint(), exports_logpoint));