agent-dbg 0.1.0

package/src/commands/blackbox-rm.ts

@@ -0,0 +1,57 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+
+registerCommand("blackbox-rm", 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 patterns: string[] = [];
+	if (args.subcommand) {
+		if (args.subcommand === "all") {
+			patterns.push("all");
+		} else {
+			patterns.push(args.subcommand);
+			for (const p of args.positionals) {
+				patterns.push(p);
+			}
+		}
+	}
+
+	if (patterns.length === 0) {
+		console.error("No patterns specified");
+		console.error("  -> Try: ndbg blackbox-rm node_modules");
+		console.error("  -> Try: ndbg blackbox-rm all");
+		return 1;
+	}
+
+	const client = new DaemonClient(session);
+	const response = await client.request("blackbox-rm", { patterns });
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const data = response.data as string[];
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+	} else {
+		if (data.length === 0) {
+			console.log("All blackbox patterns removed");
+		} else {
+			console.log("Blackbox patterns:");
+			for (const p of data) {
+				console.log(`  ${p}`);
+			}
+		}
+	}
+
+	return 0;
+});

package/src/commands/blackbox.ts

@@ -0,0 +1,48 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+
+registerCommand("blackbox", 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 patterns: string[] = [];
+	if (args.subcommand) {
+		patterns.push(args.subcommand);
+	}
+	for (const p of args.positionals) {
+		patterns.push(p);
+	}
+
+	if (patterns.length === 0) {
+		console.error("No patterns specified");
+		console.error("  -> Try: ndbg blackbox node_modules");
+		return 1;
+	}
+
+	const client = new DaemonClient(session);
+	const response = await client.request("blackbox", { patterns });
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const data = response.data as string[];
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+	} else {
+		console.log("Blackbox patterns:");
+		for (const p of data) {
+			console.log(`  ${p}`);
+		}
+	}
+
+	return 0;
+});

package/src/commands/break-ls.ts

@@ -0,0 +1,57 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+
+registerCommand("break-ls", 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("break-ls");
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const data = response.data as Array<{
+		ref: string;
+		type: "BP" | "LP";
+		url: string;
+		line: number;
+		column?: number;
+		condition?: string;
+		hitCount?: number;
+		template?: string;
+	}>;
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+	} else {
+		if (data.length === 0) {
+			console.log("No breakpoints or logpoints set");
+		} else {
+			for (const bp of data) {
+				const loc = `${bp.url}:${bp.line}`;
+				let line = `${bp.ref} ${loc}`;
+				if (bp.type === "LP" && bp.template) {
+					line += ` (log: ${bp.template})`;
+				}
+				if (bp.condition) {
+					line += ` [condition: ${bp.condition}]`;
+				}
+				if (bp.hitCount) {
+					line += ` [hit-count: ${bp.hitCount}]`;
+				}
+				console.log(line);
+			}
+		}
+	}
+
+	return 0;
+});

package/src/commands/break-rm.ts

@@ -0,0 +1,40 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+
+registerCommand("break-rm", 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 breakpoint ref specified");
+		console.error("  -> Try: ndbg break-rm BP#1");
+		return 1;
+	}
+
+	const client = new DaemonClient(session);
+	const response = await client.request("break-rm", { ref });
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	if (args.global.json) {
+		console.log(JSON.stringify({ ok: true, ref }, null, 2));
+	} else {
+		if (ref === "all") {
+			console.log("All breakpoints and logpoints removed");
+		} else {
+			console.log(`${ref} removed`);
+		}
+	}
+
+	return 0;
+});

package/src/commands/break-toggle.ts

@@ -0,0 +1,42 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+
+registerCommand("break-toggle", 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 breakpoint ref specified");
+		console.error("  -> Try: ndbg break-toggle BP#1");
+		return 1;
+	}
+
+	const client = new DaemonClient(session);
+	const response = await client.request("break-toggle", { ref });
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const data = response.data as { ref: string; state: "enabled" | "disabled" };
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+	} else {
+		if (data.ref === "all") {
+			console.log(`All breakpoints ${data.state}`);
+		} else {
+			console.log(`${data.ref} ${data.state}`);
+		}
+	}
+
+	return 0;
+});

package/src/commands/break.ts

@@ -0,0 +1,145 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+
+registerCommand("break", 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 patternFlag = typeof args.flags.pattern === "string" ? args.flags.pattern : undefined;
+	const shouldContinue = args.flags.continue === true;
+
+	let file: string;
+	let line: number;
+
+	if (patternFlag) {
+		// --pattern urlRegex:line
+		const lastColon = patternFlag.lastIndexOf(":");
+		if (lastColon === -1 || lastColon === 0) {
+			console.error(`Invalid --pattern target: "${patternFlag}"`);
+			console.error("  -> Try: ndbg break --pattern 'app\\.js':42");
+			return 1;
+		}
+		file = patternFlag.slice(0, lastColon);
+		line = parseInt(patternFlag.slice(lastColon + 1), 10);
+		if (Number.isNaN(line) || line <= 0) {
+			console.error(`Invalid line number in --pattern "${patternFlag}"`);
+			return 1;
+		}
+	} else {
+		const target = args.subcommand;
+		if (!target) {
+			console.error("No target specified");
+			console.error("  -> Try: ndbg break src/app.ts:42");
+			return 1;
+		}
+
+		// Parse file:line from the target
+		const lastColon = target.lastIndexOf(":");
+		if (lastColon === -1 || lastColon === 0) {
+			console.error(`Invalid breakpoint target: "${target}"`);
+			console.error("  -> Try: ndbg break src/app.ts:42");
+			return 1;
+		}
+
+		file = target.slice(0, lastColon);
+		line = parseInt(target.slice(lastColon + 1), 10);
+		if (Number.isNaN(line) || line <= 0) {
+			console.error(`Invalid line number in "${target}"`);
+			console.error("  -> Try: ndbg break src/app.ts:42");
+			return 1;
+		}
+	}
+
+	const condition = typeof args.flags.condition === "string" ? args.flags.condition : undefined;
+	const hitCount =
+		typeof args.flags["hit-count"] === "string" ? parseInt(args.flags["hit-count"], 10) : undefined;
+	const logTemplate = typeof args.flags.log === "string" ? args.flags.log : undefined;
+
+	const client = new DaemonClient(session);
+
+	// If --log is provided, create a logpoint instead
+	if (logTemplate) {
+		const response = await client.request("logpoint", {
+			file,
+			line,
+			template: logTemplate,
+			condition,
+		});
+
+		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: ${logTemplate})`);
+		}
+
+		return 0;
+	}
+
+	const breakArgs: Record<string, unknown> = {
+		file,
+		line,
+		condition,
+		hitCount,
+	};
+	if (patternFlag) {
+		breakArgs.urlRegex = file;
+	}
+
+	const response = await client.request("break", breakArgs);
+
+	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}`;
+		let msg = `${data.ref} set at ${loc}`;
+		if (condition) {
+			msg += ` (condition: ${condition})`;
+		}
+		if (hitCount) {
+			msg += ` (hit-count: ${hitCount})`;
+		}
+		console.log(msg);
+	}
+
+	// If --continue flag is set, also send a continue request
+	if (shouldContinue) {
+		const contResponse = await client.request("continue");
+		if (!contResponse.ok) {
+			console.error(`${contResponse.error}`);
+			return 1;
+		}
+		if (!args.global.json) {
+			console.log("Continued");
+		}
+	}
+
+	return 0;
+});

package/src/commands/breakable.ts

@@ -0,0 +1,69 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+
+registerCommand("breakable", 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 breakable src/app.ts:10-20");
+		return 1;
+	}
+
+	// Parse file:start-end from the target
+	const lastColon = target.lastIndexOf(":");
+	if (lastColon === -1 || lastColon === 0) {
+		console.error(`Invalid target format: "${target}"`);
+		console.error("  -> Expected: <file>:<start>-<end>");
+		return 1;
+	}
+
+	const file = target.slice(0, lastColon);
+	const range = target.slice(lastColon + 1);
+	const dashIdx = range.indexOf("-");
+	if (dashIdx === -1) {
+		console.error(`Invalid range format: "${range}"`);
+		console.error("  -> Expected: <start>-<end>");
+		return 1;
+	}
+
+	const startLine = parseInt(range.slice(0, dashIdx), 10);
+	const endLine = parseInt(range.slice(dashIdx + 1), 10);
+	if (Number.isNaN(startLine) || Number.isNaN(endLine) || startLine <= 0 || endLine <= 0) {
+		console.error(`Invalid line numbers in "${range}"`);
+		console.error("  -> Expected: <start>-<end>");
+		return 1;
+	}
+
+	const client = new DaemonClient(session);
+	const response = await client.request("breakable", { file, startLine, endLine });
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const data = response.data as Array<{ line: number; column: number }>;
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+	} else {
+		if (data.length === 0) {
+			console.log("No breakable locations in range");
+		} else {
+			for (const loc of data) {
+				console.log(`  ${file}:${loc.line}:${loc.column}`);
+			}
+		}
+	}
+
+	return 0;
+});

package/src/commands/catch.ts

@@ -0,0 +1,38 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+
+const VALID_MODES = new Set(["all", "uncaught", "caught", "none"]);
+
+registerCommand("catch", 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 mode = args.subcommand ?? "all";
+	if (!VALID_MODES.has(mode)) {
+		console.error(`Invalid catch mode: "${mode}"`);
+		console.error("  -> Try: ndbg catch [all | uncaught | caught | none]");
+		return 1;
+	}
+
+	const client = new DaemonClient(session);
+	const response = await client.request("catch", { mode });
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	if (args.global.json) {
+		console.log(JSON.stringify({ mode }, null, 2));
+	} else {
+		console.log(`Exception pause mode: ${mode}`);
+	}
+
+	return 0;
+});

package/src/commands/console.ts

@@ -0,0 +1,61 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+import type { ConsoleMessage } 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("console", 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 consoleArgs: Record<string, unknown> = {};
+	if (typeof args.flags.level === "string") {
+		consoleArgs.level = args.flags.level;
+	}
+	if (typeof args.flags.since === "string") {
+		consoleArgs.since = parseInt(args.flags.since, 10);
+	}
+	if (args.flags.clear === true) {
+		consoleArgs.clear = true;
+	}
+
+	const response = await client.request("console", consoleArgs);
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const messages = response.data as ConsoleMessage[];
+
+	if (args.global.json) {
+		console.log(JSON.stringify(messages, null, 2));
+		return 0;
+	}
+
+	if (messages.length === 0) {
+		console.log("(no console messages)");
+		return 0;
+	}
+
+	for (const msg of messages) {
+		const ts = formatTimestamp(msg.timestamp);
+		console.log(`[${ts}] [${msg.level}] ${msg.text}`);
+	}
+
+	return 0;
+});

package/src/commands/continue.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("continue", 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("continue");
+
+	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/eval.ts

@@ -0,0 +1,70 @@
+import { registerCommand } from "../cli/registry.ts";
+import { DaemonClient } from "../daemon/client.ts";
+
+registerCommand("eval", 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;
+	}
+
+	// Build expression from subcommand + positionals
+	const parts: string[] = [];
+	if (args.subcommand) {
+		parts.push(args.subcommand);
+	}
+	parts.push(...args.positionals);
+	const expression = parts.join(" ");
+
+	if (!expression) {
+		console.error("No expression specified");
+		console.error("  -> Try: ndbg eval 1 + 2");
+		return 1;
+	}
+
+	const evalArgs: Record<string, unknown> = {
+		expression,
+	};
+
+	if (typeof args.flags.frame === "string") {
+		evalArgs.frame = args.flags.frame;
+	}
+	if (args.flags["side-effect-free"] === true) {
+		evalArgs.throwOnSideEffect = true;
+	}
+	if (typeof args.flags.timeout === "string") {
+		evalArgs.timeout = parseInt(args.flags.timeout, 10);
+	}
+	if (args.flags.await === true) {
+		evalArgs.awaitPromise = true;
+	}
+
+	const client = new DaemonClient(session);
+	const response = await client.request("eval", evalArgs);
+
+	if (!response.ok) {
+		console.error(`${response.error}`);
+		if (response.suggestion) console.error(`  ${response.suggestion}`);
+		return 1;
+	}
+
+	const data = response.data as {
+		ref: string;
+		type: string;
+		value: string;
+		objectId?: string;
+	};
+
+	if (args.global.json) {
+		console.log(JSON.stringify(data, null, 2));
+		return 0;
+	}
+
+	if (args.flags.silent !== true) {
+		console.log(`${data.ref}  ${data.value}`);
+	}
+
+	return 0;
+});