agent-dbg 0.1.0

package/src/daemon/spawn.ts

@@ -0,0 +1,53 @@
+import { existsSync } from "node:fs";
+import { getSocketPath } from "./paths.ts";
+
+const POLL_INTERVAL_MS = 50;
+const SPAWN_TIMEOUT_MS = 5000;
+
+export async function spawnDaemon(
+	session: string,
+	options: { port?: number; timeout?: number } = {},
+): Promise<void> {
+	const socketPath = getSocketPath(session);
+
+	// Build the command to spawn ourselves as a daemon.
+	// process.execPath is the runtime (bun or compiled binary).
+	// process.argv[1] is the script being run (src/main.ts or undefined for compiled).
+	const spawnArgs: string[] = [];
+	const execPath = process.execPath;
+	const scriptPath = process.argv[1];
+
+	// If argv[1] exists and is a .ts file, we're running via `bun run src/main.ts`
+	// Otherwise we're running as a compiled binary
+	if (scriptPath && scriptPath.endsWith(".ts")) {
+		spawnArgs.push(execPath, "run", scriptPath);
+	} else {
+		spawnArgs.push(execPath);
+	}
+
+	spawnArgs.push("--daemon", session);
+	if (options.timeout !== undefined) {
+		spawnArgs.push("--timeout", String(options.timeout));
+	}
+
+	const proc = Bun.spawn(spawnArgs, {
+		detached: true,
+		stdin: "ignore",
+		stdout: "ignore",
+		stderr: "ignore",
+	});
+
+	// Unref so the parent process can exit
+	proc.unref();
+
+	// Wait for socket file to appear
+	const deadline = Date.now() + SPAWN_TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		if (existsSync(socketPath)) {
+			return;
+		}
+		await Bun.sleep(POLL_INTERVAL_MS);
+	}
+
+	throw new Error(`Daemon for session "${session}" failed to start within ${SPAWN_TIMEOUT_MS}ms`);
+}

package/src/formatter/errors.ts

@@ -0,0 +1,15 @@
+export function formatError(message: string, details?: string[], suggestion?: string): string {
+	const lines: string[] = [`\u2717 ${message}`];
+
+	if (details) {
+		for (const detail of details) {
+			lines.push(`  ${detail}`);
+		}
+	}
+
+	if (suggestion) {
+		lines.push(`  \u2192 Try: ${suggestion}`);
+	}
+
+	return lines.join("\n");
+}

package/src/formatter/source.ts

@@ -0,0 +1,74 @@
+export interface SourceLine {
+	lineNumber: number;
+	content: string;
+	isCurrent?: boolean;
+	currentColumn?: number; // 1-based column on current line
+	hasBreakpoint?: boolean;
+}
+
+const MAX_LINE_WIDTH = 120;
+
+/** Trim a long line to a window around the column, adding … on truncated sides. Returns trimmed content and adjusted column offset (0-based). */
+function trimLine(content: string, column?: number): { text: string; caretOffset?: number } {
+	const col = column !== undefined ? column - 1 : undefined; // 0-based index
+
+	if (content.length <= MAX_LINE_WIDTH) {
+		return { text: content, caretOffset: col };
+	}
+
+	const anchor = col ?? 0;
+	const half = Math.floor(MAX_LINE_WIDTH / 2);
+
+	let start = anchor - half;
+	let end = anchor + half;
+
+	if (start < 0) {
+		end -= start;
+		start = 0;
+	}
+	if (end > content.length) {
+		start -= end - content.length;
+		end = content.length;
+		if (start < 0) start = 0;
+	}
+
+	const hasPrefix = start > 0;
+	const hasSuffix = end < content.length;
+	const prefix = hasPrefix ? "\u2026" : "";
+	const suffix = hasSuffix ? "\u2026" : "";
+	const adjustedCaret = col !== undefined ? col - start + (hasPrefix ? 1 : 0) : undefined;
+
+	return { text: `${prefix}${content.slice(start, end)}${suffix}`, caretOffset: adjustedCaret };
+}
+
+export function formatSource(lines: SourceLine[]): string {
+	if (lines.length === 0) return "";
+
+	// Determine the max line number width for alignment
+	const maxLineNum = Math.max(...lines.map((l) => l.lineNumber));
+	const numWidth = String(maxLineNum).length;
+
+	const result: string[] = [];
+	for (const line of lines) {
+		const num = String(line.lineNumber).padStart(numWidth);
+		let marker = "  ";
+		if (line.isCurrent && line.hasBreakpoint) {
+			marker = "\u2192\u25CF";
+		} else if (line.isCurrent) {
+			marker = " \u2192";
+		} else if (line.hasBreakpoint) {
+			marker = " \u25CF";
+		}
+		const trimmed = line.isCurrent
+			? trimLine(line.content, line.currentColumn)
+			: trimLine(line.content);
+		result.push(`${marker} ${num}\u2502${trimmed.text}`);
+
+		// Add column indicator under current line
+		if (line.isCurrent && trimmed.caretOffset !== undefined && trimmed.caretOffset >= 0) {
+			const gutterWidth = numWidth + 4; // marker(2) + space(1) + numWidth + │(1)
+			result.push(`${" ".repeat(gutterWidth)}${" ".repeat(trimmed.caretOffset)}^`);
+		}
+	}
+	return result.join("\n");
+}

package/src/formatter/stack.ts

@@ -0,0 +1,70 @@
+export interface StackFrame {
+	ref: string;
+	functionName: string;
+	file: string;
+	line: number;
+	column?: number;
+	isAsync?: boolean;
+	isBlackboxed?: boolean;
+}
+
+export function formatStack(frames: StackFrame[]): string {
+	const outputLines: string[] = [];
+
+	// First pass: collapse consecutive blackboxed frames and compute column widths
+	const segments: (StackFrame | { blackboxedCount: number })[] = [];
+
+	let i = 0;
+	while (i < frames.length) {
+		const frame = frames[i];
+		if (!frame) break;
+		if (frame.isBlackboxed) {
+			let count = 0;
+			while (i < frames.length && frames[i]?.isBlackboxed) {
+				count++;
+				i++;
+			}
+			segments.push({ blackboxedCount: count });
+		} else {
+			segments.push(frame);
+			i++;
+		}
+	}
+
+	// Compute column widths from visible frames
+	let maxRefLen = 0;
+	let maxNameLen = 0;
+	for (const seg of segments) {
+		if ("ref" in seg) {
+			maxRefLen = Math.max(maxRefLen, seg.ref.length);
+			maxNameLen = Math.max(maxNameLen, seg.functionName.length);
+		}
+	}
+
+	for (const seg of segments) {
+		if ("blackboxedCount" in seg) {
+			const label =
+				seg.blackboxedCount === 1
+					? "\u250A ... 1 framework frame (blackboxed)"
+					: `\u250A ... ${seg.blackboxedCount} framework frames (blackboxed)`;
+			outputLines.push(label);
+			continue;
+		}
+
+		const frame = seg;
+
+		if (frame.isAsync) {
+			outputLines.push("\u250A async gap");
+		}
+
+		const ref = frame.ref.padEnd(maxRefLen);
+		const name = frame.functionName.padEnd(maxNameLen);
+		const loc =
+			frame.column !== undefined
+				? `${frame.file}:${frame.line}:${frame.column}`
+				: `${frame.file}:${frame.line}`;
+		outputLines.push(`${ref}  ${name}  ${loc}`);
+	}
+
+	return outputLines.join("\n");
+}

package/src/formatter/values.ts

@@ -0,0 +1,269 @@
+export interface RemoteObject {
+	type: string;
+	subtype?: string;
+	className?: string;
+	description?: string;
+	value?: unknown;
+	objectId?: string;
+	preview?: ObjectPreview;
+	unserializableValue?: string;
+}
+
+export interface ObjectPreview {
+	type: string;
+	subtype?: string;
+	description?: string;
+	overflow: boolean;
+	properties: PropertyPreview[];
+	entries?: EntryPreview[];
+}
+
+export interface PropertyPreview {
+	name: string;
+	type: string;
+	value?: string;
+	subtype?: string;
+}
+
+export interface EntryPreview {
+	key?: PropertyPreview;
+	value: PropertyPreview;
+}
+
+function truncate(str: string, max: number): string {
+	if (str.length <= max) return str;
+	return `${str.slice(0, max - 3)}...`;
+}
+
+function formatPreviewValue(prop: PropertyPreview): string {
+	if (prop.subtype === "null") return "null";
+	if (prop.type === "string") return `"${prop.value ?? ""}"`;
+	if (prop.type === "undefined") return "undefined";
+	if (prop.type === "object" || prop.type === "function") {
+		return prop.value ?? prop.subtype ?? prop.type;
+	}
+	return prop.value ?? "undefined";
+}
+
+function formatObjectWithPreview(obj: RemoteObject, maxLen: number): string {
+	const preview = obj.preview;
+	if (!preview) {
+		const className = obj.className ?? "Object";
+		return truncate(`${className} {...}`, maxLen);
+	}
+
+	const className = preview.description ?? obj.className ?? "Object";
+
+	const props = preview.properties.map((p) => `${p.name}: ${formatPreviewValue(p)}`).join(", ");
+
+	const suffix = preview.overflow ? ", ..." : "";
+	const result = `${className} { ${props}${suffix} }`;
+	if (result.length > maxLen) {
+		// Try to fit by truncating the props portion
+		const prefix = `${className} { `;
+		const end = preview.overflow ? ", ... }" : " }";
+		const available = maxLen - prefix.length - end.length;
+		if (available > 3) {
+			return `${prefix}${truncate(props, available)}${end}`;
+		}
+		return truncate(`${className} {...}`, maxLen);
+	}
+	return result;
+}
+
+function formatArray(obj: RemoteObject, maxLen: number): string {
+	const desc = obj.description ?? "Array";
+	const preview = obj.preview;
+
+	if (!preview) {
+		return truncate(desc, maxLen);
+	}
+
+	const items = preview.properties.map((p) => formatPreviewValue(p)).join(", ");
+	const suffix = preview.overflow ? ", ..." : "";
+	const result = `${desc} [ ${items}${suffix} ]`;
+	if (result.length > maxLen) {
+		const prefix = `${desc} [ `;
+		const end = preview.overflow ? ", ... ]" : " ]";
+		const available = maxLen - prefix.length - end.length;
+		if (available > 3) {
+			return `${prefix}${truncate(items, available)}${end}`;
+		}
+		return truncate(desc, maxLen);
+	}
+	return result;
+}
+
+function formatFunction(obj: RemoteObject): string {
+	const desc = obj.description ?? "";
+	// Extract function name and params from description like "function processResult(job) { ... }"
+	const match = desc.match(/^(?:async\s+)?(?:function\s*\*?\s*)?(\w*)\s*\(([^)]*)\)/);
+	if (match) {
+		const name = match[1] || "anonymous";
+		const params = match[2] ?? "";
+		return `Function ${name}(${params})`;
+	}
+	// Arrow functions or other forms
+	const arrowMatch = desc.match(/^(?:async\s+)?(\w+)\s*=>\s*/);
+	if (arrowMatch) {
+		return `Function ${arrowMatch[1]}=> ...`;
+	}
+	const name = obj.className ?? "Function";
+	return `Function ${name}`;
+}
+
+function formatPromise(obj: RemoteObject, maxLen: number): string {
+	const preview = obj.preview;
+	if (!preview?.properties.length) {
+		return truncate("Promise { <pending> }", maxLen);
+	}
+
+	const status = preview.properties.find((p) => p.name === "[[PromiseState]]");
+	const value = preview.properties.find((p) => p.name === "[[PromiseResult]]");
+
+	if (!status) {
+		return truncate("Promise { <pending> }", maxLen);
+	}
+
+	const state = status.value;
+	if (state === "pending") {
+		return truncate("Promise { <pending> }", maxLen);
+	}
+	if (state === "fulfilled") {
+		const val = value ? formatPreviewValue(value) : "undefined";
+		return truncate(`Promise { <resolved: ${val}> }`, maxLen);
+	}
+	if (state === "rejected") {
+		const val = value ? formatPreviewValue(value) : "undefined";
+		return truncate(`Promise { <rejected: ${val}> }`, maxLen);
+	}
+	return truncate(`Promise { <${state}> }`, maxLen);
+}
+
+function formatError(obj: RemoteObject, maxLen: number): string {
+	const desc = obj.description ?? "";
+	const lines = desc.split("\n");
+	const messageLine = lines[0] ?? "Error";
+	// Extract first stack frame location
+	const frameLine = lines.find((l) => l.trim().startsWith("at "));
+	if (frameLine) {
+		const locMatch = frameLine.match(/\(([^)]+)\)/);
+		const loc = locMatch ? locMatch[1] : frameLine.replace(/^\s*at\s+/, "");
+		return truncate(`${messageLine} (at ${loc})`, maxLen);
+	}
+	return truncate(messageLine, maxLen);
+}
+
+function formatMap(obj: RemoteObject, maxLen: number): string {
+	const desc = obj.description ?? "Map";
+	const preview = obj.preview;
+
+	if (!preview?.entries) {
+		return truncate(`${desc} {}`, maxLen);
+	}
+
+	const items = preview.entries
+		.map((e) => {
+			const key = e.key ? formatPreviewValue(e.key) : "?";
+			const val = formatPreviewValue(e.value);
+			return `${key} => ${val}`;
+		})
+		.join(", ");
+
+	const suffix = preview.overflow ? ", ..." : "";
+	const result = `${desc} { ${items}${suffix} }`;
+	return truncate(result, maxLen);
+}
+
+function formatSet(obj: RemoteObject, maxLen: number): string {
+	const desc = obj.description ?? "Set";
+	const preview = obj.preview;
+
+	if (!preview?.entries) {
+		return truncate(`${desc} {}`, maxLen);
+	}
+
+	const items = preview.entries.map((e) => formatPreviewValue(e.value)).join(", ");
+	const suffix = preview.overflow ? ", ..." : "";
+	const result = `${desc} { ${items}${suffix} }`;
+	return truncate(result, maxLen);
+}
+
+function formatBuffer(obj: RemoteObject, maxLen: number): string {
+	const desc = obj.description ?? "Buffer";
+	const preview = obj.preview;
+
+	if (!preview) {
+		return truncate(desc, maxLen);
+	}
+
+	// Preview properties contain the byte values
+	const bytes = preview.properties
+		.slice(0, 5)
+		.map((p) => {
+			const num = Number.parseInt(p.value ?? "0", 10);
+			return num.toString(16).padStart(2, "0");
+		})
+		.join(" ");
+
+	const suffix = preview.overflow ? " ..." : "";
+	return truncate(`${desc} <${bytes}${suffix}>`, maxLen);
+}
+
+function formatDate(obj: RemoteObject, maxLen: number): string {
+	const desc = obj.description ?? "";
+	return truncate(`Date("${desc}")`, maxLen);
+}
+
+function formatRegExp(obj: RemoteObject, maxLen: number): string {
+	const desc = obj.description ?? "//";
+	return truncate(desc, maxLen);
+}
+
+export function formatValue(obj: RemoteObject, maxLen: number = 80): string {
+	// Unserializable values (NaN, Infinity, -Infinity, -0, bigint)
+	if (obj.unserializableValue !== undefined) {
+		return truncate(obj.unserializableValue, maxLen);
+	}
+
+	// Primitives
+	if (obj.type === "undefined") return "undefined";
+	if (obj.type === "boolean") return String(obj.value);
+	if (obj.type === "number") return String(obj.value);
+	if (obj.type === "bigint") return truncate(`${obj.value}n`, maxLen);
+	if (obj.type === "string") return truncate(`"${obj.value}"`, maxLen);
+	if (obj.type === "symbol") return truncate(obj.description ?? "Symbol()", maxLen);
+
+	// Functions
+	if (obj.type === "function") return truncate(formatFunction(obj), maxLen);
+
+	// Null
+	if (obj.subtype === "null") return "null";
+
+	// Object subtypes
+	if (obj.subtype === "array" || obj.subtype === "typedarray") {
+		return formatArray(obj, maxLen);
+	}
+	if (obj.subtype === "regexp") return formatRegExp(obj, maxLen);
+	if (obj.subtype === "date") return formatDate(obj, maxLen);
+	if (obj.subtype === "map" || obj.subtype === "weakmap") {
+		return formatMap(obj, maxLen);
+	}
+	if (obj.subtype === "set" || obj.subtype === "weakset") {
+		return formatSet(obj, maxLen);
+	}
+	if (obj.subtype === "error") return formatError(obj, maxLen);
+	if (obj.subtype === "promise") return formatPromise(obj, maxLen);
+	if (obj.subtype === "arraybuffer" || obj.subtype === "dataview") {
+		return formatBuffer(obj, maxLen);
+	}
+
+	// Buffer className
+	if (obj.className === "Buffer") return formatBuffer(obj, maxLen);
+
+	// Generic object with preview
+	if (obj.type === "object") return formatObjectWithPreview(obj, maxLen);
+
+	// Fallback
+	return truncate(obj.description ?? String(obj.value ?? obj.type), maxLen);
+}

package/src/formatter/variables.ts

@@ -0,0 +1,20 @@
+export interface Variable {
+	ref: string;
+	name: string;
+	value: string;
+}
+
+export function formatVariables(vars: Variable[]): string {
+	if (vars.length === 0) return "";
+
+	const maxRefLen = Math.max(...vars.map((v) => v.ref.length));
+	const maxNameLen = Math.max(...vars.map((v) => v.name.length));
+
+	return vars
+		.map((v) => {
+			const ref = v.ref.padEnd(maxRefLen);
+			const name = v.name.padEnd(maxNameLen);
+			return `${ref}  ${name}  ${v.value}`;
+		})
+		.join("\n");
+}

package/src/main.ts

@@ -0,0 +1,45 @@
+#!/usr/bin/env bun
+// When spawned as a daemon subprocess, run daemon entry directly
+if (process.argv.includes("--daemon")) {
+	await import("./daemon/entry.ts");
+} else {
+	await import("./commands/launch.ts");
+	await import("./commands/attach.ts");
+	await import("./commands/stop.ts");
+	await import("./commands/sessions.ts");
+	await import("./commands/status.ts");
+	await import("./commands/state.ts");
+	await import("./commands/continue.ts");
+	await import("./commands/step.ts");
+	await import("./commands/pause.ts");
+	await import("./commands/run-to.ts");
+	await import("./commands/break.ts");
+	await import("./commands/break-rm.ts");
+	await import("./commands/break-ls.ts");
+	await import("./commands/logpoint.ts");
+	await import("./commands/catch.ts");
+	await import("./commands/source.ts");
+	await import("./commands/scripts.ts");
+	await import("./commands/stack.ts");
+	await import("./commands/search.ts");
+	await import("./commands/console.ts");
+	await import("./commands/exceptions.ts");
+	await import("./commands/eval.ts");
+	await import("./commands/vars.ts");
+	await import("./commands/props.ts");
+	await import("./commands/blackbox.ts");
+	await import("./commands/blackbox-ls.ts");
+	await import("./commands/blackbox-rm.ts");
+	await import("./commands/set.ts");
+	await import("./commands/set-return.ts");
+	await import("./commands/hotpatch.ts");
+	await import("./commands/break-toggle.ts");
+	await import("./commands/breakable.ts");
+	await import("./commands/restart-frame.ts");
+	await import("./commands/sourcemap.ts");
+	const { parseArgs, run } = await import("./cli/parser.ts");
+
+	const args = parseArgs(process.argv.slice(2));
+	const exitCode = await run(args);
+	process.exit(exitCode);
+}