agent-dbg 0.1.0 → 0.1.2

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "agent-dbg",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Node.js Debugger CLI for AI Agents",
   "type": "module",
   "bin": {
-    "ndbg": "./src/main.ts"
+    "agent-dbg": "./dist/main.js"
   },
   "scripts": {
     "dev": "bun run src/main.ts",
-    "build": "bun build src/main.ts --compile --outfile dist/ndbg",
+    "build": "bun build src/main.ts --outdir dist --target=bun",
     "test": "bun test",
     "lint": "biome check .",
     "format": "biome check --write .",

package/src/cdp/client.ts

@@ -1,4 +1,5 @@
 import type { ProtocolMapping } from "devtools-protocol/types/protocol-mapping.js";
+import type { CdpLogger } from "./logger.ts";
 import type { CdpEvent, CdpRequest, CdpResponse } from "./types.ts";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -21,20 +22,24 @@ export class CdpClient {
 	private pending = new Map<number, PendingRequest>();
 	private listeners = new Map<string, Set<AnyHandler>>();
 	private isConnected = false;
+	private logger: CdpLogger | null;
+	/** Map request id → method name for response logging */
+	private sentMethods = new Map<number, string>();
 
-	private constructor(ws: WebSocket) {
+	private constructor(ws: WebSocket, logger?: CdpLogger) {
 		this.ws = ws;
+		this.logger = logger ?? null;
 		this.isConnected = true;
 		this.setupHandlers();
 	}
 
-	static async connect(wsUrl: string): Promise<CdpClient> {
+	static async connect(wsUrl: string, logger?: CdpLogger): Promise<CdpClient> {
 		return new Promise<CdpClient>((resolve, reject) => {
 			const ws = new WebSocket(wsUrl);
 
 			const onOpen = () => {
 				ws.removeEventListener("error", onError);
-				const client = new CdpClient(ws);
+				const client = new CdpClient(ws, logger);
 				resolve(client);
 			};
 
@@ -53,7 +58,6 @@ export class CdpClient {
 		method: T,
 		...params: ProtocolMapping.Commands[T]["paramsType"]
 	): Promise<ProtocolMapping.Commands[T]["returnType"]>;
-	async send(method: string, params?: Record<string, unknown>): Promise<unknown>;
 	async send(method: string, ...args: unknown[]): Promise<unknown> {
 		if (!this.isConnected) {
 			throw new Error("CDP client is not connected");
@@ -66,9 +70,13 @@ export class CdpClient {
 			request.params = params;
 		}
 
+		this.sentMethods.set(id, method);
+		this.logger?.logSend(id, method, params as Record<string, unknown> | undefined);
+
 		return new Promise<unknown>((resolve, reject) => {
 			const timer = setTimeout(() => {
 				this.pending.delete(id);
+				this.sentMethods.delete(id);
 				reject(new Error(`CDP request timed out: ${method} (id=${id})`));
 			}, DEFAULT_TIMEOUT_MS);
 
@@ -173,6 +181,10 @@ export class CdpClient {
 
 		if ("id" in parsed && typeof parsed.id === "number") {
 			const response = parsed as CdpResponse;
+			const method = this.sentMethods.get(response.id) ?? "unknown";
+			this.sentMethods.delete(response.id);
+			this.logger?.logResponse(response.id, method, response.result, response.error);
+
 			const pending = this.pending.get(response.id);
 			if (!pending) {
 				return;
@@ -187,6 +199,8 @@ export class CdpClient {
 			}
 		} else if ("method" in parsed) {
 			const event = parsed as CdpEvent;
+			this.logger?.logEvent(event.method, event.params);
+
 			const handlers = this.listeners.get(event.method);
 			if (handlers) {
 				for (const handler of handlers) {

package/src/cdp/logger.ts

@@ -0,0 +1,69 @@
+import { appendFileSync, writeFileSync } from "node:fs";
+
+export interface CdpLogEntry {
+	ts: number;
+	dir: "send" | "recv" | "event";
+	method: string;
+	id?: number;
+	params?: Record<string, unknown>;
+	result?: unknown;
+	error?: { code: number; message: string };
+	ms?: number;
+}
+
+export class CdpLogger {
+	private logPath: string;
+	/** Map request id → { method, sentAt } for latency tracking */
+	private pending = new Map<number, { method: string; sentAt: number }>();
+
+	constructor(logPath: string) {
+		this.logPath = logPath;
+		// Truncate log file on creation (new session = fresh log)
+		writeFileSync(logPath, "");
+	}
+
+	logSend(id: number, method: string, params?: Record<string, unknown>): void {
+		this.pending.set(id, { method, sentAt: Date.now() });
+		const entry: CdpLogEntry = { ts: Date.now(), dir: "send", method, id };
+		if (params !== undefined) {
+			entry.params = params;
+		}
+		this.append(entry);
+	}
+
+	logResponse(
+		id: number,
+		method: string,
+		result?: unknown,
+		error?: { code: number; message: string },
+	): void {
+		const pending = this.pending.get(id);
+		const ms = pending ? Date.now() - pending.sentAt : undefined;
+		if (pending) this.pending.delete(id);
+
+		const entry: CdpLogEntry = { ts: Date.now(), dir: "recv", method, id };
+		if (ms !== undefined) entry.ms = ms;
+		if (error) {
+			entry.error = error;
+		} else if (result !== undefined) {
+			entry.result = result;
+		}
+		this.append(entry);
+	}
+
+	logEvent(method: string, params?: unknown): void {
+		const entry: CdpLogEntry = { ts: Date.now(), dir: "event", method };
+		if (params !== undefined) {
+			entry.params = params as Record<string, unknown>;
+		}
+		this.append(entry);
+	}
+
+	clear(): void {
+		writeFileSync(this.logPath, "");
+	}
+
+	private append(entry: CdpLogEntry): void {
+		appendFileSync(this.logPath, `${JSON.stringify(entry)}\n`);
+	}
+}

package/src/cli/parser.ts

@@ -98,6 +98,7 @@ export function parseArgs(argv: string[]): ParsedArgs {
 				s: "stack",
 				b: "breakpoints",
 				c: "code",
+				f: "follow",
 			};
 			const mapped = shortMap[key];
 			if (mapped) {
@@ -141,7 +142,7 @@ export async function run(args: ParsedArgs): Promise<number> {
 	const handler = registry.get(args.command);
 	if (!handler) {
 		console.error(`✗ Unknown command: ${args.command}`);
-		console.error("  → Try: ndbg --help");
+		console.error("  → Try: agent-dbg --help");
 		return 1;
 	}
 
@@ -155,9 +156,9 @@ export async function run(args: ParsedArgs): Promise<number> {
 }
 
 function printHelp(): void {
-	console.log(`ndbg — Node.js debugger CLI for AI agents
+	console.log(`agent-dbg — Node.js debugger CLI for AI agents
 
-Usage: ndbg <command> [options]
+Usage: agent-dbg <command> [options]
 
 Session:
   launch [--brk] <command...>      Start + attach debugger
@@ -218,6 +219,10 @@ Source Maps:
   sourcemap [file]                 Show source map info
   sourcemap --disable              Disable resolution globally
 
+Diagnostics:
+  logs [-f|--follow]               Show CDP protocol log
+    [--limit N] [--domain <name>] [--clear]
+
 Global flags:
   --session NAME                   Target session (default: "default")
   --json                           JSON output
@@ -227,61 +232,67 @@ Global flags:
 }
 
 function printHelpAgent(): void {
-	console.log(`ndbg — Node.js debugger CLI for AI agents
+	console.log(`agent-dbg — Node.js debugger CLI for AI agents
 
 CORE LOOP:
-  1. ndbg launch --brk "node app.js"    → pauses at first line, returns state
-  2. ndbg break src/file.ts:42          → set breakpoint
-  3. ndbg continue                      → run to breakpoint, returns state
-  4. Inspect: ndbg vars, ndbg eval, ndbg props @v1
-  5. Mutate/fix: ndbg set @v1 value, ndbg hotpatch src/file.ts
+  1. agent-dbg launch --brk "node app.js"    → pauses at first line, returns state
+  2. agent-dbg break src/file.ts:42          → set breakpoint
+  3. agent-dbg continue                      → run to breakpoint, returns state
+  4. Inspect: agent-dbg vars, agent-dbg eval, agent-dbg props @v1
+  5. Mutate/fix: agent-dbg set @v1 value, agent-dbg hotpatch src/file.ts
   6. Repeat from 3
 
 REFS: Every output assigns @refs. Use them everywhere:
-  @v1..@vN  variables    |  ndbg props @v1, ndbg set @v2 true
-  @f0..@fN  stack frames |  ndbg eval --frame @f1
-  BP#1..N   breakpoints  |  ndbg break-rm BP#1, ndbg break-toggle BP#1
+  @v1..@vN  variables    |  agent-dbg props @v1, agent-dbg set @v2 true
+  @f0..@fN  stack frames |  agent-dbg eval --frame @f1
+  BP#1..N   breakpoints  |  agent-dbg break-rm BP#1, agent-dbg break-toggle BP#1
 
 EXECUTION (all return state automatically):
-  ndbg continue              Resume to next breakpoint
-  ndbg step [over|into|out]  Step one statement
-  ndbg run-to file:line      Continue to location
-  ndbg pause                 Interrupt running process
-  ndbg restart-frame [@fN]   Re-run frame from beginning
+  agent-dbg continue              Resume to next breakpoint
+  agent-dbg step [over|into|out]  Step one statement
+  agent-dbg run-to file:line      Continue to location
+  agent-dbg pause                 Interrupt running process
+  agent-dbg restart-frame [@fN]   Re-run frame from beginning
 
 BREAKPOINTS:
-  ndbg break file:line [--condition expr] [--hit-count N] [--continue]
-  ndbg break --pattern "regex":line
-  ndbg break-rm <BP#|all>    Remove breakpoints
-  ndbg break-ls              List breakpoints
-  ndbg break-toggle <BP#|all>  Enable/disable breakpoints
-  ndbg breakable file:start-end  Valid breakpoint locations
-  ndbg logpoint file:line "template \${var}" [--condition expr]
-  ndbg catch [all|uncaught|caught|none]
+  agent-dbg break file:line [--condition expr] [--hit-count N] [--continue]
+  agent-dbg break --pattern "regex":line
+  agent-dbg break-rm <BP#|all>    Remove breakpoints
+  agent-dbg break-ls              List breakpoints
+  agent-dbg break-toggle <BP#|all>  Enable/disable breakpoints
+  agent-dbg breakable file:start-end  Valid breakpoint locations
+  agent-dbg logpoint file:line "template \${var}" [--condition expr]
+  agent-dbg catch [all|uncaught|caught|none]
 
 INSPECTION:
-  ndbg state [-v|-s|-b|-c] [--depth N] [--lines N] [--frame @fN] [--all-scopes] [--compact] [--generated]
-  ndbg vars [name...] [--frame @fN] [--all-scopes]
-  ndbg stack [--async-depth N] [--generated]
-  ndbg eval <expr> [--frame @fN] [--silent] [--timeout MS] [--side-effect-free]
-  ndbg props @ref [--own] [--depth N] [--private] [--internal]
-  ndbg source [--lines N] [--file path] [--all] [--generated]
-  ndbg search "query" [--regex] [--case-sensitive] [--file id]
-  ndbg scripts [--filter pattern]
-  ndbg console [--since N] [--level type] [--clear]
-  ndbg exceptions [--since N]
+  agent-dbg state [-v|-s|-b|-c] [--depth N] [--lines N] [--frame @fN] [--all-scopes] [--compact] [--generated]
+  agent-dbg vars [name...] [--frame @fN] [--all-scopes]
+  agent-dbg stack [--async-depth N] [--generated]
+  agent-dbg eval <expr> [--frame @fN] [--silent] [--timeout MS] [--side-effect-free]
+  agent-dbg props @ref [--own] [--depth N] [--private] [--internal]
+  agent-dbg source [--lines N] [--file path] [--all] [--generated]
+  agent-dbg search "query" [--regex] [--case-sensitive] [--file id]
+  agent-dbg scripts [--filter pattern]
+  agent-dbg console [--since N] [--level type] [--clear]
+  agent-dbg exceptions [--since N]
 
 MUTATION:
-  ndbg set <@ref|name> <value>   Change variable
-  ndbg set-return <value>        Change return value (at return point)
-  ndbg hotpatch <file> [--dry-run]  Live-edit code (no restart!)
+  agent-dbg set <@ref|name> <value>   Change variable
+  agent-dbg set-return <value>        Change return value (at return point)
+  agent-dbg hotpatch <file> [--dry-run]  Live-edit code (no restart!)
 
 BLACKBOXING:
-  ndbg blackbox <pattern...>     Skip stepping into matching scripts
-  ndbg blackbox-ls               List current patterns
-  ndbg blackbox-rm <pattern|all> Remove patterns
+  agent-dbg blackbox <pattern...>     Skip stepping into matching scripts
+  agent-dbg blackbox-ls               List current patterns
+  agent-dbg blackbox-rm <pattern|all> Remove patterns
 
 SOURCE MAPS:
-  ndbg sourcemap [file]          Show source map info
-  ndbg sourcemap --disable       Disable resolution globally`);
+  agent-dbg sourcemap [file]          Show source map info
+  agent-dbg sourcemap --disable       Disable resolution globally
+
+DIAGNOSTICS:
+  agent-dbg logs [-f|--follow]        Show CDP protocol log
+  agent-dbg logs --limit 100          Show last N entries (default: 50)
+  agent-dbg logs --domain Debugger    Filter by CDP domain
+  agent-dbg logs --clear              Clear the log file`);
 }

package/src/commands/attach.ts

@@ -8,14 +8,14 @@ registerCommand("attach", async (args) => {
 
 	if (!target) {
 		console.error("No target specified");
-		console.error("  -> Try: ndbg attach <ws-url | port>");
+		console.error("  -> Try: agent-dbg attach <ws-url | port>");
 		return 1;
 	}
 
 	// Check if daemon already running
 	if (DaemonClient.isRunning(session)) {
 		console.error(`Session "${session}" is already active`);
-		console.error(`  -> Try: ndbg stop --session ${session}`);
+		console.error(`  -> Try: agent-dbg stop --session ${session}`);
 		return 1;
 	}
 

package/src/commands/blackbox-ls.ts

@@ -6,7 +6,7 @@ registerCommand("blackbox-ls", async (args) => {
 
 	if (!DaemonClient.isRunning(session)) {
 		console.error(`No active session "${session}"`);
-		console.error("  -> Try: ndbg launch --brk node app.js");
+		console.error("  -> Try: agent-dbg launch --brk node app.js");
 		return 1;
 	}
 

package/src/commands/blackbox-rm.ts

@@ -6,7 +6,7 @@ registerCommand("blackbox-rm", async (args) => {
 
 	if (!DaemonClient.isRunning(session)) {
 		console.error(`No active session "${session}"`);
-		console.error("  -> Try: ndbg launch --brk node app.js");
+		console.error("  -> Try: agent-dbg launch --brk node app.js");
 		return 1;
 	}
 
@@ -24,8 +24,8 @@ registerCommand("blackbox-rm", async (args) => {
 
 	if (patterns.length === 0) {
 		console.error("No patterns specified");
-		console.error("  -> Try: ndbg blackbox-rm node_modules");
-		console.error("  -> Try: ndbg blackbox-rm all");
+		console.error("  -> Try: agent-dbg blackbox-rm node_modules");
+		console.error("  -> Try: agent-dbg blackbox-rm all");
 		return 1;
 	}
 

package/src/commands/blackbox.ts

@@ -6,7 +6,7 @@ registerCommand("blackbox", async (args) => {
 
 	if (!DaemonClient.isRunning(session)) {
 		console.error(`No active session "${session}"`);
-		console.error("  -> Try: ndbg launch --brk node app.js");
+		console.error("  -> Try: agent-dbg launch --brk node app.js");
 		return 1;
 	}
 
@@ -20,7 +20,7 @@ registerCommand("blackbox", async (args) => {
 
 	if (patterns.length === 0) {
 		console.error("No patterns specified");
-		console.error("  -> Try: ndbg blackbox node_modules");
+		console.error("  -> Try: agent-dbg blackbox node_modules");
 		return 1;
 	}
 

package/src/commands/break-ls.ts

@@ -1,12 +1,13 @@
 import { registerCommand } from "../cli/registry.ts";
 import { DaemonClient } from "../daemon/client.ts";
+import { shortPath } from "../formatter/path.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");
+		console.error("  -> Try: agent-dbg launch --brk node app.js");
 		return 1;
 	}
 
@@ -37,7 +38,7 @@ registerCommand("break-ls", async (args) => {
 			console.log("No breakpoints or logpoints set");
 		} else {
 			for (const bp of data) {
-				const loc = `${bp.url}:${bp.line}`;
+				const loc = `${shortPath(bp.url)}:${bp.line}`;
 				let line = `${bp.ref} ${loc}`;
 				if (bp.type === "LP" && bp.template) {
 					line += ` (log: ${bp.template})`;

package/src/commands/break-rm.ts

@@ -6,14 +6,14 @@ registerCommand("break-rm", async (args) => {
 
 	if (!DaemonClient.isRunning(session)) {
 		console.error(`No active session "${session}"`);
-		console.error("  -> Try: ndbg launch --brk node app.js");
+		console.error("  -> Try: agent-dbg 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");
+		console.error("  -> Try: agent-dbg break-rm BP#1");
 		return 1;
 	}
 

package/src/commands/break-toggle.ts

@@ -6,14 +6,14 @@ registerCommand("break-toggle", async (args) => {
 
 	if (!DaemonClient.isRunning(session)) {
 		console.error(`No active session "${session}"`);
-		console.error("  -> Try: ndbg launch --brk node app.js");
+		console.error("  -> Try: agent-dbg 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");
+		console.error("  -> Try: agent-dbg break-toggle BP#1");
 		return 1;
 	}
 

package/src/commands/break.ts

@@ -1,12 +1,44 @@
 import { registerCommand } from "../cli/registry.ts";
 import { DaemonClient } from "../daemon/client.ts";
+import { shortPath } from "../formatter/path.ts";
+
+function parseFileLineColumn(
+	target: string,
+): { file: string; line: number; column?: number } | null {
+	// Match file:line:column or file:line
+	// Walk backwards to find the last two colon-separated numbers
+	const lastColon = target.lastIndexOf(":");
+	if (lastColon === -1 || lastColon === 0) return null;
+
+	const afterLast = target.slice(lastColon + 1);
+	const maybeNum = parseInt(afterLast, 10);
+	if (Number.isNaN(maybeNum) || maybeNum <= 0) return null;
+
+	const beforeLast = target.slice(0, lastColon);
+	const secondColon = beforeLast.lastIndexOf(":");
+	if (secondColon > 0) {
+		const afterSecond = beforeLast.slice(secondColon + 1);
+		const maybeLine = parseInt(afterSecond, 10);
+		if (!Number.isNaN(maybeLine) && maybeLine > 0) {
+			// file:line:column
+			return {
+				file: beforeLast.slice(0, secondColon),
+				line: maybeLine,
+				column: maybeNum,
+			};
+		}
+	}
+
+	// file:line
+	return { file: beforeLast, line: maybeNum };
+}
 
 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");
+		console.error("  -> Try: agent-dbg launch --brk node app.js");
 		return 1;
 	}
 
@@ -15,13 +47,14 @@ registerCommand("break", async (args) => {
 
 	let file: string;
 	let line: number;
+	let column: number | undefined;
 
 	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");
+			console.error("  -> Try: agent-dbg break --pattern 'app\\.js':42");
 			return 1;
 		}
 		file = patternFlag.slice(0, lastColon);
@@ -34,25 +67,20 @@ registerCommand("break", async (args) => {
 		const target = args.subcommand;
 		if (!target) {
 			console.error("No target specified");
-			console.error("  -> Try: ndbg break src/app.ts:42");
+			console.error("  -> Try: agent-dbg break src/app.ts:42");
 			return 1;
 		}
 
-		// Parse file:line from the target
-		const lastColon = target.lastIndexOf(":");
-		if (lastColon === -1 || lastColon === 0) {
+		// Parse file:line[:column] from the target
+		const parsed = parseFileLineColumn(target);
+		if (!parsed) {
 			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");
+			console.error("  -> Try: agent-dbg break src/app.ts:42 or src/app.ts:42:5");
 			return 1;
 		}
+		file = parsed.file;
+		line = parsed.line;
+		column = parsed.column;
 	}
 
 	const condition = typeof args.flags.condition === "string" ? args.flags.condition : undefined;
@@ -85,7 +113,7 @@ registerCommand("break", async (args) => {
 		if (args.global.json) {
 			console.log(JSON.stringify(data, null, 2));
 		} else {
-			const loc = `${data.location.url}:${data.location.line}`;
+			const loc = `${shortPath(data.location.url)}:${data.location.line}`;
 			console.log(`${data.ref} set at ${loc} (log: ${logTemplate})`);
 		}
 
@@ -97,6 +125,7 @@ registerCommand("break", async (args) => {
 		line,
 		condition,
 		hitCount,
+		column,
 	};
 	if (patternFlag) {
 		breakArgs.urlRegex = file;
@@ -118,7 +147,7 @@ registerCommand("break", async (args) => {
 	if (args.global.json) {
 		console.log(JSON.stringify(data, null, 2));
 	} else {
-		const loc = `${data.location.url}:${data.location.line}`;
+		const loc = `${shortPath(data.location.url)}:${data.location.line}`;
 		let msg = `${data.ref} set at ${loc}`;
 		if (condition) {
 			msg += ` (condition: ${condition})`;

package/src/commands/breakable.ts

@@ -6,14 +6,14 @@ registerCommand("breakable", async (args) => {
 
 	if (!DaemonClient.isRunning(session)) {
 		console.error(`No active session "${session}"`);
-		console.error("  -> Try: ndbg launch --brk node app.js");
+		console.error("  -> Try: agent-dbg 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");
+		console.error("  -> Try: agent-dbg breakable src/app.ts:10-20");
 		return 1;
 	}
 

package/src/commands/catch.ts

@@ -8,14 +8,14 @@ registerCommand("catch", async (args) => {
 
 	if (!DaemonClient.isRunning(session)) {
 		console.error(`No active session "${session}"`);
-		console.error("  -> Try: ndbg launch --brk node app.js");
+		console.error("  -> Try: agent-dbg 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]");
+		console.error("  -> Try: agent-dbg catch [all | uncaught | caught | none]");
 		return 1;
 	}
 

package/src/commands/console.ts

@@ -15,7 +15,7 @@ registerCommand("console", async (args) => {
 
 	if (!DaemonClient.isRunning(session)) {
 		console.error(`No active session "${session}"`);
-		console.error("  -> Try: ndbg launch --brk node app.js");
+		console.error("  -> Try: agent-dbg launch --brk node app.js");
 		return 1;
 	}
 

package/src/commands/continue.ts

@@ -1,13 +1,14 @@
 import { registerCommand } from "../cli/registry.ts";
 import { DaemonClient } from "../daemon/client.ts";
-import type { SessionStatus } from "../daemon/session.ts";
+import type { StateSnapshot } from "../daemon/session.ts";
+import { printState } from "./print-state.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");
+		console.error("  -> Try: agent-dbg launch --brk node app.js");
 		return 1;
 	}
 
@@ -20,27 +21,13 @@ registerCommand("continue", async (args) => {
 		return 1;
 	}
 
-	const data = response.data as SessionStatus;
+	const data = response.data as StateSnapshot;
 
 	if (args.global.json) {
 		console.log(JSON.stringify(data, null, 2));
 	} else {
-		printStatus(data);
+		printState(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

@@ -6,7 +6,7 @@ registerCommand("eval", async (args) => {
 
 	if (!DaemonClient.isRunning(session)) {
 		console.error(`No active session "${session}"`);
-		console.error("  -> Try: ndbg launch --brk node app.js");
+		console.error("  -> Try: agent-dbg launch --brk node app.js");
 		return 1;
 	}
 
@@ -20,7 +20,7 @@ registerCommand("eval", async (args) => {
 
 	if (!expression) {
 		console.error("No expression specified");
-		console.error("  -> Try: ndbg eval 1 + 2");
+		console.error("  -> Try: agent-dbg eval 1 + 2");
 		return 1;
 	}