agent-dbg 0.1.0

package/src/commands/exceptions.ts

@@ -0,0 +1,61 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+import type { ExceptionEntry } from "../daemon/session.ts";
+
+function formatTimestamp(ts: number): string {
+	const d = new Date(ts);
+	const hh = String(d.getHours()).padStart(2, "0");
+	const mm = String(d.getMinutes()).padStart(2, "0");
+	const ss = String(d.getSeconds()).padStart(2, "0");
+	return `${hh}:${mm}:${ss}`;
+}
+
+registerCommand("exceptions", async (args) => {
+	const session = args.global.session;
+
+	if (!DaemonClient.isRunning(session)) {
+		console.error(`No active session "${session}"`);
+		console.error("  -> Try: ndbg launch --brk node app.js");
+		return 1;
+	}
+
+	const client = new DaemonClient(session);
+
+	const exceptionsArgs: Record<string, unknown> = {};
+	if (typeof args.flags.since === "string") {
+		exceptionsArgs.since = parseInt(args.flags.since, 10);
+	}
+
+	const response = await client.request("exceptions", exceptionsArgs);
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const entries = response.data as ExceptionEntry[];
+
+	if (args.global.json) {
+		console.log(JSON.stringify(entries, null, 2));
+		return 0;
+	}
+
+	if (entries.length === 0) {
+		console.log("(no exceptions)");
+		return 0;
+	}
+
+	for (const entry of entries) {
+		const ts = formatTimestamp(entry.timestamp);
+		console.log(`[${ts}] ${entry.text}`);
+		if (entry.description) {
+			console.log(`  ${entry.description}`);
+		}
+		if (entry.stackTrace) {
+			console.log(entry.stackTrace);
+		}
+	}
+
+	return 0;
+});

package/src/commands/hotpatch.ts

@@ -0,0 +1,67 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+
+registerCommand("hotpatch", async (args) => {
+	const session = args.global.session;
+
+	if (!DaemonClient.isRunning(session)) {
+		console.error(`No active session "${session}"`);
+		console.error("  -> Try: ndbg launch --brk node app.js");
+		return 1;
+	}
+
+	const file = args.subcommand;
+	if (!file) {
+		console.error("No file specified");
+		console.error("  -> Try: ndbg hotpatch app.js");
+		return 1;
+	}
+
+	// Read the file contents
+	let source: string;
+	try {
+		source = await Bun.file(file).text();
+	} catch {
+		console.error(`Cannot read file: ${file}`);
+		return 1;
+	}
+
+	const hotpatchArgs: Record<string, unknown> = {
+		file,
+		source,
+	};
+
+	if (args.flags["dry-run"] === true) {
+		hotpatchArgs.dryRun = true;
+	}
+
+	const client = new DaemonClient(session);
+	const response = await client.request("hotpatch", hotpatchArgs);
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const data = response.data as {
+		status: string;
+		callFrames?: unknown[];
+		exceptionDetails?: unknown;
+	};
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+		return 0;
+	}
+
+	if (data.exceptionDetails) {
+		console.error(`hotpatch failed: ${JSON.stringify(data.exceptionDetails)}`);
+		return 1;
+	}
+
+	const dryRunLabel = args.flags["dry-run"] === true ? " (dry-run)" : "";
+	console.log(`hotpatch ${data.status}${dryRunLabel}: ${file}`);
+
+	return 0;
+});

package/src/commands/launch.ts

@@ -0,0 +1,69 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+import { spawnDaemon } from "../daemon/spawn.ts";
+
+registerCommand("launch", async (args) => {
+	const session = args.global.session;
+	const brk = args.flags.brk === true;
+	const port = typeof args.flags.port === "string" ? parseInt(args.flags.port, 10) : undefined;
+	const timeout =
+		typeof args.flags.timeout === "string" ? parseInt(args.flags.timeout, 10) : undefined;
+
+	// Reconstruct the full command from subcommand + positionals.
+	// The parser treats the second non-flag word as subcommand, but for launch
+	// it should be part of the command to execute.
+	// e.g., "ndbg launch node app.js" -> subcommand="node", positionals=["app.js"]
+	// We need command = ["node", "app.js"]
+	const command = args.subcommand ? [args.subcommand, ...args.positionals] : [...args.positionals];
+
+	if (command.length === 0) {
+		console.error("No command specified");
+		console.error("  -> Try: ndbg launch --brk node app.js");
+		return 1;
+	}
+
+	// Check if daemon already running for this session
+	if (DaemonClient.isRunning(session)) {
+		console.error(`Session "${session}" is already active`);
+		console.error(`  -> Try: ndbg stop --session ${session}`);
+		return 1;
+	}
+
+	// Spawn daemon
+	await spawnDaemon(session, { timeout });
+
+	// Send launch command to daemon
+	const client = new DaemonClient(session);
+	const response = await client.request("launch", { command, brk, port });
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	// Format output
+	const data = response.data as {
+		pid: number;
+		wsUrl: string;
+		paused: boolean;
+		pauseInfo?: { reason: string; url?: string; line?: number };
+	};
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+	} else {
+		console.log(`Session "${session}" started (pid ${data.pid})`);
+		if (data.paused && data.pauseInfo) {
+			const col = data.pauseInfo.column !== undefined ? `:${data.pauseInfo.column + 1}` : "";
+			const loc = data.pauseInfo.url
+				? `${data.pauseInfo.url}:${data.pauseInfo.line}${col}`
+				: "unknown";
+			console.log(`Paused at ${loc}`);
+		} else {
+			console.log("Running");
+		}
+	}
+
+	return 0;
+});

package/src/commands/logpoint.ts

@@ -0,0 +1,78 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+
+registerCommand("logpoint", async (args) => {
+	const session = args.global.session;
+
+	if (!DaemonClient.isRunning(session)) {
+		console.error(`No active session "${session}"`);
+		console.error("  -> Try: ndbg launch --brk node app.js");
+		return 1;
+	}
+
+	const target = args.subcommand;
+	if (!target) {
+		console.error("No target specified");
+		console.error('  -> Try: ndbg logpoint src/app.ts:42 "x =", x');
+		return 1;
+	}
+
+	// Parse file:line from the target
+	const lastColon = target.lastIndexOf(":");
+	if (lastColon === -1 || lastColon === 0) {
+		console.error(`Invalid logpoint target: "${target}"`);
+		console.error('  -> Try: ndbg logpoint src/app.ts:42 "x =", x');
+		return 1;
+	}
+
+	const file = target.slice(0, lastColon);
+	const line = parseInt(target.slice(lastColon + 1), 10);
+	if (Number.isNaN(line) || line <= 0) {
+		console.error(`Invalid line number in "${target}"`);
+		console.error('  -> Try: ndbg logpoint src/app.ts:42 "x =", x');
+		return 1;
+	}
+
+	// Template is the first positional argument (after the subcommand)
+	const template = args.positionals[0];
+	if (!template) {
+		console.error("No log template specified");
+		console.error('  -> Try: ndbg logpoint src/app.ts:42 "x =", x');
+		return 1;
+	}
+
+	const condition = typeof args.flags.condition === "string" ? args.flags.condition : undefined;
+	const maxEmissions =
+		typeof args.flags["max-emissions"] === "string"
+			? parseInt(args.flags["max-emissions"], 10)
+			: undefined;
+
+	const client = new DaemonClient(session);
+	const response = await client.request("logpoint", {
+		file,
+		line,
+		template,
+		condition,
+		maxEmissions,
+	});
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const data = response.data as {
+		ref: string;
+		location: { url: string; line: number; column?: number };
+	};
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+	} else {
+		const loc = `${data.location.url}:${data.location.line}`;
+		console.log(`${data.ref} set at ${loc} (log: ${template})`);
+	}
+
+	return 0;
+});

package/src/commands/pause.ts

@@ -0,0 +1,46 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+import type { SessionStatus } from "../daemon/session.ts";
+
+registerCommand("pause", async (args) => {
+	const session = args.global.session;
+
+	if (!DaemonClient.isRunning(session)) {
+		console.error(`No active session "${session}"`);
+		console.error("  -> Try: ndbg launch --brk node app.js");
+		return 1;
+	}
+
+	const client = new DaemonClient(session);
+	const response = await client.request("pause");
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const data = response.data as SessionStatus;
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+	} else {
+		printStatus(data);
+	}
+
+	return 0;
+});
+
+function printStatus(data: SessionStatus): void {
+	if (data.state === "paused" && data.pauseInfo) {
+		const col = data.pauseInfo.column !== undefined ? `:${data.pauseInfo.column + 1}` : "";
+		const loc = data.pauseInfo.url
+			? `${data.pauseInfo.url}:${(data.pauseInfo.line ?? 0) + 1}${col}`
+			: "unknown";
+		console.log(`Paused at ${loc} (${data.pauseInfo.reason})`);
+	} else if (data.state === "running") {
+		console.log("Running");
+	} else {
+		console.log(`${data.state}`);
+	}
+}

package/src/commands/props.ts

@@ -0,0 +1,77 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+
+registerCommand("props", async (args) => {
+	const session = args.global.session;
+
+	if (!DaemonClient.isRunning(session)) {
+		console.error(`No active session "${session}"`);
+		console.error("  -> Try: ndbg launch --brk node app.js");
+		return 1;
+	}
+
+	const ref = args.subcommand;
+	if (!ref) {
+		console.error("No ref specified");
+		console.error("  -> Try: ndbg props @v1");
+		return 1;
+	}
+
+	const propsArgs: Record<string, unknown> = {
+		ref,
+	};
+
+	if (args.flags.own === true || args.flags.own === false) {
+		propsArgs.own = args.flags.own;
+	}
+	if (args.flags.internal === true) {
+		propsArgs.internal = true;
+	}
+	if (args.flags.private === true) {
+		propsArgs.internal = true;
+	}
+	if (typeof args.flags.depth === "string") {
+		propsArgs.depth = parseInt(args.flags.depth, 10);
+	}
+
+	const client = new DaemonClient(session);
+	const response = await client.request("props", propsArgs);
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const data = response.data as Array<{
+		ref?: string;
+		name: string;
+		type: string;
+		value: string;
+		isOwn?: boolean;
+		isAccessor?: boolean;
+	}>;
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+		return 0;
+	}
+
+	if (data.length === 0) {
+		console.log("(no properties)");
+		return 0;
+	}
+
+	// Format output with aligned columns
+	const maxRefLen = Math.max(...data.map((p) => (p.ref ? p.ref.length : 0)));
+	const maxNameLen = Math.max(...data.map((p) => p.name.length));
+
+	for (const prop of data) {
+		const refCol = prop.ref ? prop.ref.padEnd(maxRefLen) : " ".repeat(maxRefLen);
+		const nameCol = prop.name.padEnd(maxNameLen);
+		const accessor = prop.isAccessor ? " [accessor]" : "";
+		console.log(`${refCol}  ${nameCol}  ${prop.value}${accessor}`);
+	}
+
+	return 0;
+});

package/src/commands/restart-frame.ts

@@ -0,0 +1,36 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+import type { SessionStatus } from "../daemon/session.ts";
+
+registerCommand("restart-frame", async (args) => {
+	const session = args.global.session;
+
+	if (!DaemonClient.isRunning(session)) {
+		console.error(`No active session "${session}"`);
+		console.error("  -> Try: ndbg launch --brk node app.js");
+		return 1;
+	}
+
+	const frameRef = args.subcommand ?? undefined;
+
+	const client = new DaemonClient(session);
+	const response = await client.request("restart-frame", {
+		frameRef,
+	});
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const data = response.data as SessionStatus | { status: string };
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+	} else {
+		console.log("Frame restarted");
+	}
+
+	return 0;
+});

package/src/commands/run-to.ts

@@ -0,0 +1,70 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+import type { SessionStatus } from "../daemon/session.ts";
+
+registerCommand("run-to", async (args) => {
+	const session = args.global.session;
+
+	if (!DaemonClient.isRunning(session)) {
+		console.error(`No active session "${session}"`);
+		console.error("  -> Try: ndbg launch --brk node app.js");
+		return 1;
+	}
+
+	// Parse file:line from subcommand
+	// e.g., "ndbg run-to src/file.ts:42" -> subcommand = "src/file.ts:42"
+	const target = args.subcommand ?? args.positionals[0];
+	if (!target) {
+		console.error("No target specified");
+		console.error("  -> Try: ndbg run-to src/file.ts:42");
+		return 1;
+	}
+
+	const lastColon = target.lastIndexOf(":");
+	if (lastColon === -1 || lastColon === 0) {
+		console.error(`Invalid target format: "${target}"`);
+		console.error("  -> Expected: <file>:<line>");
+		return 1;
+	}
+
+	const file = target.slice(0, lastColon);
+	const line = parseInt(target.slice(lastColon + 1), 10);
+	if (Number.isNaN(line) || line <= 0) {
+		console.error(`Invalid line number in "${target}"`);
+		console.error("  -> Expected: <file>:<line>");
+		return 1;
+	}
+
+	const client = new DaemonClient(session);
+	const response = await client.request("run-to", { file, line });
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const data = response.data as SessionStatus;
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+	} else {
+		printStatus(data);
+	}
+
+	return 0;
+});
+
+function printStatus(data: SessionStatus): void {
+	if (data.state === "paused" && data.pauseInfo) {
+		const col = data.pauseInfo.column !== undefined ? `:${data.pauseInfo.column + 1}` : "";
+		const loc = data.pauseInfo.url
+			? `${data.pauseInfo.url}:${(data.pauseInfo.line ?? 0) + 1}${col}`
+			: "unknown";
+		console.log(`Paused at ${loc} (${data.pauseInfo.reason})`);
+	} else if (data.state === "running") {
+		console.log("Running");
+	} else {
+		console.log(`${data.state}`);
+	}
+}

package/src/commands/scripts.ts

@@ -0,0 +1,57 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+
+registerCommand("scripts", async (args) => {
+	const session = args.global.session;
+
+	if (!DaemonClient.isRunning(session)) {
+		console.error(`No active session "${session}"`);
+		console.error("  -> Try: ndbg launch --brk node app.js");
+		return 1;
+	}
+
+	const client = new DaemonClient(session);
+
+	const scriptsArgs: Record<string, unknown> = {};
+
+	// Accept filter from --filter flag or from subcommand
+	if (typeof args.flags.filter === "string") {
+		scriptsArgs.filter = args.flags.filter;
+	} else if (args.subcommand) {
+		scriptsArgs.filter = args.subcommand;
+	}
+
+	const response = await client.request("scripts", scriptsArgs);
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const data = response.data as Array<{
+		scriptId: string;
+		url: string;
+		sourceMapURL?: string;
+	}>;
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+		return 0;
+	}
+
+	if (data.length === 0) {
+		console.log("No scripts loaded");
+		return 0;
+	}
+
+	for (const script of data) {
+		let line = `${script.scriptId}  ${script.url}`;
+		if (script.sourceMapURL) {
+			line += `  (sourcemap: ${script.sourceMapURL})`;
+		}
+		console.log(line);
+	}
+
+	return 0;
+});

package/src/commands/search.ts

@@ -0,0 +1,73 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+
+registerCommand("search", async (args) => {
+	const session = args.global.session;
+
+	if (!DaemonClient.isRunning(session)) {
+		console.error(`No active session "${session}"`);
+		console.error("  -> Try: ndbg launch --brk node app.js");
+		return 1;
+	}
+
+	// Query from subcommand + positionals
+	const parts: string[] = [];
+	if (args.subcommand) {
+		parts.push(args.subcommand);
+	}
+	for (const p of args.positionals) {
+		parts.push(p);
+	}
+	const query = parts.join(" ");
+
+	if (!query) {
+		console.error("No search query specified");
+		console.error("  -> Try: ndbg search <query> [--regex] [--case-sensitive]");
+		return 1;
+	}
+
+	const client = new DaemonClient(session);
+
+	const searchArgs: Record<string, unknown> = { query };
+
+	if (args.flags.regex === true) {
+		searchArgs.isRegex = true;
+	}
+	if (args.flags["case-sensitive"] === true) {
+		searchArgs.caseSensitive = true;
+	}
+	if (typeof args.flags.file === "string") {
+		searchArgs.scriptId = args.flags.file;
+	}
+
+	const response = await client.request("search", searchArgs);
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const data = response.data as Array<{
+		url: string;
+		line: number;
+		column: number;
+		content: string;
+	}>;
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+		return 0;
+	}
+
+	if (data.length === 0) {
+		console.log("No matches found");
+		return 0;
+	}
+
+	for (const match of data) {
+		console.log(`${match.url}:${match.line}: ${match.content}`);
+	}
+
+	return 0;
+});