agent-dbg 0.1.0

package/src/daemon/client.ts

@@ -0,0 +1,147 @@
+import { existsSync, readdirSync } from "node:fs";
+import { type DaemonResponse, DaemonResponseSchema } from "../protocol/messages.ts";
+import { getSocketDir, getSocketPath } from "./paths.ts";
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+export class DaemonClient {
+	private session: string;
+	private socketPath: string;
+
+	constructor(session: string) {
+		this.session = session;
+		this.socketPath = getSocketPath(session);
+	}
+
+	async request(cmd: string, args: Record<string, unknown> = {}): Promise<DaemonResponse> {
+		const message = `${JSON.stringify({ cmd, args })}\n`;
+		const sessionName = this.session;
+		const socketPath = this.socketPath;
+
+		return new Promise<DaemonResponse>((resolve, reject) => {
+			let buffer = "";
+			let settled = false;
+
+			const timer = setTimeout(() => {
+				if (!settled) {
+					settled = true;
+					reject(new Error(`Request timed out after ${DEFAULT_TIMEOUT_MS}ms`));
+				}
+			}, DEFAULT_TIMEOUT_MS);
+
+			Bun.connect<undefined>({
+				unix: socketPath,
+				socket: {
+					open(socket) {
+						socket.write(message);
+					},
+					data(_socket, data) {
+						buffer += data.toString();
+						const newlineIdx = buffer.indexOf("\n");
+						if (newlineIdx !== -1) {
+							const line = buffer.slice(0, newlineIdx);
+							if (!settled) {
+								settled = true;
+								clearTimeout(timer);
+								try {
+									const parsed = DaemonResponseSchema.safeParse(JSON.parse(line));
+									if (!parsed.success) {
+										reject(new Error("Invalid response from daemon"));
+									} else {
+										resolve(parsed.data);
+									}
+								} catch {
+									reject(new Error("Invalid JSON response from daemon"));
+								}
+							}
+						}
+					},
+					close() {
+						if (!settled) {
+							settled = true;
+							clearTimeout(timer);
+							if (buffer.trim()) {
+								try {
+									const parsed = DaemonResponseSchema.safeParse(JSON.parse(buffer.trim()));
+									if (!parsed.success) {
+										reject(new Error("Invalid response from daemon"));
+									} else {
+										resolve(parsed.data);
+									}
+								} catch {
+									reject(new Error("Invalid JSON response from daemon"));
+								}
+							} else {
+								reject(new Error("Connection closed without response"));
+							}
+						}
+					},
+					error(_socket, error) {
+						if (!settled) {
+							settled = true;
+							clearTimeout(timer);
+							reject(error);
+						}
+					},
+					connectError(_socket, error) {
+						if (!settled) {
+							settled = true;
+							clearTimeout(timer);
+							reject(
+								new Error(`Daemon not running for session "${sessionName}": ${error.message}`),
+							);
+						}
+					},
+				},
+			}).catch((err) => {
+				if (!settled) {
+					settled = true;
+					clearTimeout(timer);
+					reject(
+						new Error(
+							`Cannot connect to daemon for session "${sessionName}": ${err instanceof Error ? err.message : String(err)}`,
+						),
+					);
+				}
+			});
+		});
+	}
+
+	static isRunning(session: string): boolean {
+		const socketPath = getSocketPath(session);
+		if (!existsSync(socketPath)) {
+			return false;
+		}
+		// Try connecting to verify the daemon is actually alive
+		try {
+			// Use a sync approach: check if socket file exists
+			// A true liveness check requires async connection, so we check the file
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	static async isAlive(session: string): Promise<boolean> {
+		const socketPath = getSocketPath(session);
+		if (!existsSync(socketPath)) {
+			return false;
+		}
+		try {
+			const client = new DaemonClient(session);
+			const response = await client.request("ping");
+			return response.ok === true;
+		} catch {
+			return false;
+		}
+	}
+
+	static listSessions(): string[] {
+		const dir = getSocketDir();
+		if (!existsSync(dir)) {
+			return [];
+		}
+		const files = readdirSync(dir);
+		return files.filter((f) => f.endsWith(".sock")).map((f) => f.slice(0, -5));
+	}
+}

package/src/daemon/entry.ts

@@ -0,0 +1,242 @@
+import type { DaemonRequest, DaemonResponse } from "../protocol/messages.ts";
+import { DaemonServer } from "./server.ts";
+import { DebugSession } from "./session.ts";
+
+// Session name follows --daemon in argv
+const daemonIdx = process.argv.indexOf("--daemon");
+const session = daemonIdx !== -1 ? process.argv[daemonIdx + 1] : process.argv[2];
+if (!session) {
+	console.error("Usage: ndbg --daemon <session> [--timeout <seconds>]");
+	process.exit(1);
+}
+
+let timeout = 300; // default 5 minutes
+const timeoutIdx = process.argv.indexOf("--timeout");
+if (timeoutIdx !== -1) {
+	const val = process.argv[timeoutIdx + 1];
+	if (val) {
+		timeout = parseInt(val, 10);
+		if (Number.isNaN(timeout) || timeout < 0) {
+			timeout = 300;
+		}
+	}
+}
+
+const server = new DaemonServer(session, { idleTimeout: timeout });
+const debugSession = new DebugSession(session);
+
+server.onRequest(async (req: DaemonRequest): Promise<DaemonResponse> => {
+	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 });
+			return { ok: true, data: result };
+		}
+
+		case "attach": {
+			const { target } = req.args;
+			const result = await debugSession.attach(target);
+			return { ok: true, data: result };
+		}
+
+		case "status":
+			return { ok: true, data: debugSession.getStatus() };
+
+		case "state": {
+			const stateResult = await debugSession.buildState(req.args);
+			return { ok: true, data: stateResult };
+		}
+
+		case "continue": {
+			await debugSession.continue();
+			return { ok: true, data: debugSession.getStatus() };
+		}
+
+		case "step": {
+			const { mode = "over" } = req.args;
+			await debugSession.step(mode);
+			return { ok: true, data: debugSession.getStatus() };
+		}
+
+		case "pause": {
+			await debugSession.pause();
+			return { ok: true, data: debugSession.getStatus() };
+		}
+
+		case "run-to": {
+			const { file, line } = req.args;
+			await debugSession.runTo(file, line);
+			return { ok: true, data: debugSession.getStatus() };
+		}
+
+		case "break": {
+			const { file, line, condition, hitCount, urlRegex } = req.args;
+			const bpResult = await debugSession.setBreakpoint(file, line, {
+				condition,
+				hitCount,
+				urlRegex,
+			});
+			return { ok: true, data: bpResult };
+		}
+
+		case "break-rm": {
+			const { ref } = req.args;
+			if (ref === "all") {
+				await debugSession.removeAllBreakpoints();
+				return { ok: true, data: "all removed" };
+			}
+			await debugSession.removeBreakpoint(ref);
+			return { ok: true, data: "removed" };
+		}
+
+		case "break-ls":
+			return { ok: true, data: debugSession.listBreakpoints() };
+
+		case "logpoint": {
+			const { file, line, template, condition, maxEmissions } = req.args;
+			const lpResult = await debugSession.setLogpoint(file, line, template, {
+				condition,
+				maxEmissions,
+			});
+			return { ok: true, data: lpResult };
+		}
+
+		case "catch": {
+			const { mode } = req.args;
+			await debugSession.setExceptionPause(mode);
+			return { ok: true, data: mode };
+		}
+
+		case "source": {
+			const sourceResult = await debugSession.getSource(req.args);
+			return { ok: true, data: sourceResult };
+		}
+
+		case "scripts": {
+			const { filter } = req.args;
+			const scriptsResult = debugSession.getScripts(filter);
+			return { ok: true, data: scriptsResult };
+		}
+
+		case "stack": {
+			const stackResult = debugSession.getStack(req.args);
+			return { ok: true, data: stackResult };
+		}
+
+		case "search": {
+			const { query, ...searchOptions } = req.args;
+			const searchResult = await debugSession.searchInScripts(query, searchOptions);
+			return { ok: true, data: searchResult };
+		}
+
+		case "console": {
+			const consoleResult = debugSession.getConsoleMessages(req.args);
+			return { ok: true, data: consoleResult };
+		}
+
+		case "exceptions": {
+			const exceptionsResult = debugSession.getExceptions(req.args);
+			return { ok: true, data: exceptionsResult };
+		}
+
+		case "eval": {
+			const { expression, ...evalOptions } = req.args;
+			const evalResult = await debugSession.eval(expression, evalOptions);
+			return { ok: true, data: evalResult };
+		}
+
+		case "vars": {
+			const varsResult = await debugSession.getVars(req.args);
+			return { ok: true, data: varsResult };
+		}
+
+		case "props": {
+			const { ref, ...propsOptions } = req.args;
+			const propsResult = await debugSession.getProps(ref, propsOptions);
+			return { ok: true, data: propsResult };
+		}
+
+		case "blackbox": {
+			const { patterns } = req.args;
+			const result = await debugSession.addBlackbox(patterns);
+			return { ok: true, data: result };
+		}
+
+		case "blackbox-ls": {
+			return { ok: true, data: debugSession.listBlackbox() };
+		}
+
+		case "blackbox-rm": {
+			const { patterns } = req.args;
+			const result = await debugSession.removeBlackbox(patterns);
+			return { ok: true, data: result };
+		}
+
+		case "set": {
+			const { name, value, frame } = req.args;
+			const result = await debugSession.setVariable(name, value, { frame });
+			return { ok: true, data: result };
+		}
+
+		case "set-return": {
+			const { value } = req.args;
+			const result = await debugSession.setReturnValue(value);
+			return { ok: true, data: result };
+		}
+
+		case "hotpatch": {
+			const { file, source, dryRun } = req.args;
+			const result = await debugSession.hotpatch(file, source, { dryRun });
+			return { ok: true, data: result };
+		}
+
+		case "break-toggle": {
+			const { ref } = req.args;
+			const toggleResult = await debugSession.toggleBreakpoint(ref);
+			return { ok: true, data: toggleResult };
+		}
+
+		case "breakable": {
+			const { file, startLine, endLine } = req.args;
+			const breakableResult = await debugSession.getBreakableLocations(file, startLine, endLine);
+			return { ok: true, data: breakableResult };
+		}
+
+		case "restart-frame": {
+			const { frameRef } = req.args;
+			const restartResult = await debugSession.restartFrame(frameRef);
+			return { ok: true, data: restartResult };
+		}
+
+		case "sourcemap": {
+			const { file: smFile } = req.args;
+			if (smFile) {
+				const match = debugSession.sourceMapResolver.findScriptForSource(smFile);
+				if (match) {
+					const info = debugSession.sourceMapResolver.getInfo(match.scriptId);
+					return { ok: true, data: info ? [info] : [] };
+				}
+				return { ok: true, data: [] };
+			}
+			return { ok: true, data: debugSession.sourceMapResolver.getAllInfos() };
+		}
+
+		case "sourcemap-disable": {
+			debugSession.sourceMapResolver.setDisabled(true);
+			return { ok: true, data: "disabled" };
+		}
+
+		case "stop":
+			await debugSession.stop();
+			setTimeout(() => {
+				server.stop();
+				process.exit(0);
+			}, 50);
+			return { ok: true, data: "stopped" };
+	}
+});
+
+await server.start();

package/src/daemon/paths.ts

@@ -0,0 +1,26 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+export function getSocketDir(): string {
+	const xdgRuntime = process.env.XDG_RUNTIME_DIR;
+	if (xdgRuntime) {
+		return join(xdgRuntime, "ndbg");
+	}
+	const tmpdir = process.env.TMPDIR || "/tmp";
+	return join(tmpdir, `ndbg-${process.getuid?.() ?? 0}`);
+}
+
+export function getSocketPath(session: string): string {
+	return join(getSocketDir(), `${session}.sock`);
+}
+
+export function getLockPath(session: string): string {
+	return join(getSocketDir(), `${session}.lock`);
+}
+
+export function ensureSocketDir(): void {
+	const dir = getSocketDir();
+	if (!existsSync(dir)) {
+		mkdirSync(dir, { recursive: true });
+	}
+}

package/src/daemon/server.ts

@@ -0,0 +1,185 @@
+import { existsSync, unlinkSync, writeFileSync } from "node:fs";
+import {
+	type DaemonRequest,
+	DaemonRequestSchema,
+	type DaemonResponse,
+} from "../protocol/messages.ts";
+import { ensureSocketDir, getLockPath, getSocketPath } from "./paths.ts";
+
+type RequestHandler = (req: DaemonRequest) => Promise<DaemonResponse>;
+
+export class DaemonServer {
+	private session: string;
+	private idleTimeout: number;
+	private idleTimer: ReturnType<typeof setTimeout> | null = null;
+	private handler: RequestHandler | null = null;
+	private listener: ReturnType<typeof Bun.listen> | null = null;
+	private socketPath: string;
+	private lockPath: string;
+
+	constructor(session: string, options: { idleTimeout: number }) {
+		this.session = session;
+		this.idleTimeout = options.idleTimeout;
+		this.socketPath = getSocketPath(session);
+		this.lockPath = getLockPath(session);
+	}
+
+	onRequest(handler: RequestHandler): void {
+		this.handler = handler;
+	}
+
+	async start(): Promise<void> {
+		ensureSocketDir();
+
+		// Check for existing lock file with a running process
+		if (existsSync(this.lockPath)) {
+			const existingPid = parseInt(await Bun.file(this.lockPath).text(), 10);
+			if (!Number.isNaN(existingPid) && isProcessRunning(existingPid)) {
+				throw new Error(
+					`Daemon already running for session "${this.session}" (pid ${existingPid})`,
+				);
+			}
+			// Stale lock file, clean up
+			unlinkSync(this.lockPath);
+		}
+
+		// Remove stale socket file
+		if (existsSync(this.socketPath)) {
+			unlinkSync(this.socketPath);
+		}
+
+		// Write lock file with our PID
+		writeFileSync(this.lockPath, String(process.pid));
+
+		const server = this;
+
+		this.listener = Bun.listen<{ buffer: string }>({
+			unix: this.socketPath,
+			socket: {
+				open(socket) {
+					socket.data = { buffer: "" };
+					server.resetIdleTimer();
+				},
+				data(socket, data) {
+					socket.data.buffer += data.toString();
+					const newlineIdx = socket.data.buffer.indexOf("\n");
+					if (newlineIdx === -1) return;
+
+					const line = socket.data.buffer.slice(0, newlineIdx);
+					socket.data.buffer = socket.data.buffer.slice(newlineIdx + 1);
+
+					server.handleMessage(socket, line);
+				},
+				close() {},
+				error(_socket, error) {
+					console.error(`[daemon] socket error: ${error.message}`);
+				},
+			},
+		});
+
+		this.resetIdleTimer();
+	}
+
+	private handleMessage(
+		socket: { write(data: string | Buffer | Uint8Array): number; end(): void },
+		line: string,
+	): void {
+		let json: unknown;
+		try {
+			json = JSON.parse(line);
+		} catch {
+			const errResponse: DaemonResponse = {
+				ok: false,
+				error: "Invalid JSON",
+			};
+			socket.write(`${JSON.stringify(errResponse)}\n`);
+			socket.end();
+			return;
+		}
+
+		const parsed = DaemonRequestSchema.safeParse(json);
+		if (!parsed.success) {
+			const obj = json as Record<string, unknown> | null;
+			const cmd =
+				obj && typeof obj === "object" && typeof obj.cmd === "string" ? obj.cmd : undefined;
+			const errResponse: DaemonResponse = cmd
+				? {
+						ok: false,
+						error: `Unknown command: ${cmd}`,
+						suggestion: "-> Try: ndbg --help",
+					}
+				: {
+						ok: false,
+						error: "Invalid request: must have { cmd: string, args: object }",
+					};
+			socket.write(`${JSON.stringify(errResponse)}\n`);
+			socket.end();
+			return;
+		}
+		const request: DaemonRequest = parsed.data;
+
+		if (!this.handler) {
+			const errResponse: DaemonResponse = {
+				ok: false,
+				error: "No request handler registered",
+			};
+			socket.write(`${JSON.stringify(errResponse)}\n`);
+			socket.end();
+			return;
+		}
+
+		this.handler(request)
+			.then((response) => {
+				socket.write(`${JSON.stringify(response)}\n`);
+				socket.end();
+			})
+			.catch((err) => {
+				const errResponse: DaemonResponse = {
+					ok: false,
+					error: err instanceof Error ? err.message : String(err),
+				};
+				socket.write(`${JSON.stringify(errResponse)}\n`);
+				socket.end();
+			});
+	}
+
+	resetIdleTimer(): void {
+		if (this.idleTimer) {
+			clearTimeout(this.idleTimer);
+		}
+		if (this.idleTimeout > 0) {
+			this.idleTimer = setTimeout(() => {
+				this.stop();
+			}, this.idleTimeout * 1000);
+		}
+	}
+
+	async stop(): Promise<void> {
+		if (this.idleTimer) {
+			clearTimeout(this.idleTimer);
+			this.idleTimer = null;
+		}
+
+		if (this.listener) {
+			this.listener.stop(true);
+			this.listener = null;
+		}
+
+		// Clean up socket and lock files
+		if (existsSync(this.socketPath)) {
+			unlinkSync(this.socketPath);
+		}
+		if (existsSync(this.lockPath)) {
+			unlinkSync(this.lockPath);
+		}
+	}
+}
+
+function isProcessRunning(pid: number): boolean {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}

package/src/daemon/session-blackbox.ts

@@ -0,0 +1,41 @@
+import type { DebugSession } from "./session.ts";
+
+export async function addBlackbox(session: DebugSession, patterns: string[]): Promise<string[]> {
+	if (!session.cdp) {
+		throw new Error("No active debug session");
+	}
+
+	for (const p of patterns) {
+		if (!session.blackboxPatterns.includes(p)) {
+			session.blackboxPatterns.push(p);
+		}
+	}
+
+	await session.cdp.send("Debugger.setBlackboxPatterns", {
+		patterns: session.blackboxPatterns,
+	});
+
+	return [...session.blackboxPatterns];
+}
+
+export function listBlackbox(session: DebugSession): string[] {
+	return [...session.blackboxPatterns];
+}
+
+export async function removeBlackbox(session: DebugSession, patterns: string[]): Promise<string[]> {
+	if (!session.cdp) {
+		throw new Error("No active debug session");
+	}
+
+	if (patterns.includes("all")) {
+		session.blackboxPatterns = [];
+	} else {
+		session.blackboxPatterns = session.blackboxPatterns.filter((p) => !patterns.includes(p));
+	}
+
+	await session.cdp.send("Debugger.setBlackboxPatterns", {
+		patterns: session.blackboxPatterns,
+	});
+
+	return [...session.blackboxPatterns];
+}