agent-dbg 0.1.3 → 0.1.4

package/dist/main.js

@@ -12,6 +12,1049 @@ 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";
 
@@ -6101,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") });
@@ -6110,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") });
@@ -6157,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({
@@ -6335,6 +7388,7 @@ var init_messages = __esm(() => {
     PauseRequest,
     RunToRequest,
     BreakRequest,
+    BreakFnRequest,
     BreakRmRequest,
     BreakLsRequest,
     LogpointRequest,
@@ -6414,7 +7468,7 @@ class DaemonServer {
       unix: this.socketPath,
       socket: {
         open(socket) {
-          socket.data = { buffer: "" };
+          socket.data = { buffer: "", pendingWrite: null, pendingOffset: 0 };
           server.resetIdleTimer();
         },
         data(socket, data) {
@@ -6427,6 +7481,9 @@ 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);
@@ -6436,60 +7493,69 @@ class DaemonServer {
     });
     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() {
@@ -6582,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));
     });
@@ -6686,7 +7752,7 @@ class CdpClient {
     }
   }
 }
-var DEFAULT_TIMEOUT_MS = 30000;
+var DEFAULT_TIMEOUT_MS2 = 30000;
 
 // src/cdp/logger.ts
 import { appendFileSync as appendFileSync2, writeFileSync as writeFileSync3 } from "fs";
@@ -6943,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;
@@ -8861,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;
@@ -9629,7 +10601,7 @@ class DebugSession {
   }
 }
 var INSPECTOR_URL_REGEX, INSPECTOR_TIMEOUT_MS = 5000;
-var init_session = __esm(() => {
+var init_session2 = __esm(() => {
   init_logger2();
   init_ref_table();
   init_resolver();
@@ -9643,12 +10615,19 @@ var init_session = __esm(() => {
 
 // src/daemon/entry.ts
 var exports_entry = {};
-var daemonIdx, session, timeout = 300, timeoutIdx, daemonLogger, 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_session();
   init_logger();
   init_paths();
   init_server();
-  init_session();
+  init_session2();
   daemonIdx = process.argv.indexOf("--daemon");
   session = daemonIdx !== -1 ? process.argv[daemonIdx + 1] : process.argv[2];
   if (!session) {
@@ -9673,52 +10652,62 @@ var init_entry = __esm(async () => {
     timeout
   });
   server = new DaemonServer(session, { idleTimeout: timeout, logger: daemonLogger });
-  debugSession = new DebugSession(session, { 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,
@@ -9726,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
         });
@@ -9747,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);
@@ -9875,7 +10880,7 @@ var init_registry = __esm(() => {
 });
 
 // src/daemon/client.ts
-import { existsSync as existsSync3, readFileSync, readdirSync, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync3, readdirSync, readFileSync, unlinkSync as unlinkSync2 } from "fs";
 
 class DaemonClient {
   session;
@@ -9895,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: {
@@ -10019,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, openSync } 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);
@@ -10057,7 +11062,24 @@ 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))
@@ -10105,6 +11127,7 @@ 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");
@@ -10113,7 +11136,7 @@ var init_launch = __esm(() => {
     }
     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)
@@ -10146,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>");
@@ -10159,7 +11183,7 @@ var init_attach = __esm(() => {
     const timeout2 = typeof args.flags.timeout === "string" ? parseInt(args.flags.timeout, 10) : undefined;
     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)
@@ -10919,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(() => {
@@ -12191,7 +13253,7 @@ import {
   closeSync,
   existsSync as existsSync5,
   openSync as openSync2,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   readSync,
   watch,
   writeFileSync as writeFileSync4
@@ -12271,7 +13333,7 @@ var init_logs2 = __esm(() => {
     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 = readFileSync2(logPath, "utf-8");
+    const content = readFileSync3(logPath, "utf-8");
     if (isDaemon) {
       let entries = parseDaemonEntries(content);
       if (level)
@@ -12630,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));