agent-dbg 0.1.0 → 0.1.2

package/src/commands/state.ts

@@ -1,19 +1,14 @@
 import { registerCommand } from "../cli/registry.ts";
 import { DaemonClient } from "../daemon/client.ts";
 import type { StateSnapshot } from "../daemon/session.ts";
-import type { SourceLine } from "../formatter/source.ts";
-import { formatSource } from "../formatter/source.ts";
-import type { StackFrame } from "../formatter/stack.ts";
-import { formatStack } from "../formatter/stack.ts";
-import type { Variable } from "../formatter/variables.ts";
-import { formatVariables } from "../formatter/variables.ts";
+import { printState } from "./print-state.ts";
 
 registerCommand("state", 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;
 	}
 
@@ -53,72 +48,7 @@ registerCommand("state", async (args) => {
 		return 0;
 	}
 
-	// Non-paused states
-	if (data.status !== "paused") {
-		const icon = data.status === "running" ? "\u25B6" : "\u25CB";
-		console.log(`${icon} ${data.status === "running" ? "Running" : "Idle"}`);
-		return 0;
-	}
-
-	// Paused state — header
-	const loc = data.location
-		? `${data.location.url}:${data.location.line}${data.location.column !== undefined ? `:${data.location.column}` : ""}`
-		: "unknown";
-	const reason = data.reason ?? "unknown";
-	console.log(`\u23F8 Paused at ${loc} (${reason})`);
-
-	const showAll = !stateArgs.vars && !stateArgs.stack && !stateArgs.breakpoints && !stateArgs.code;
-
-	// Source section
-	if ((showAll || stateArgs.code) && data.source?.lines) {
-		console.log("");
-		console.log("Source:");
-		const sourceLines: SourceLine[] = data.source.lines.map((l) => ({
-			lineNumber: l.line,
-			content: l.text,
-			isCurrent: l.current,
-			currentColumn: l.current ? data.location?.column : undefined,
-		}));
-		console.log(formatSource(sourceLines));
-	}
-
-	// Locals section
-	if ((showAll || stateArgs.vars) && data.locals) {
-		console.log("");
-		console.log("Locals:");
-		const vars: Variable[] = data.locals.map((v) => ({
-			ref: v.ref,
-			name: v.name,
-			value: v.value,
-		}));
-		const formatted = formatVariables(vars);
-		if (formatted) {
-			console.log(formatted);
-		} else {
-			console.log("  (no locals)");
-		}
-	}
-
-	// Stack section
-	if ((showAll || stateArgs.stack) && data.stack) {
-		console.log("");
-		console.log("Stack:");
-		const frames: StackFrame[] = data.stack.map((f) => ({
-			ref: f.ref,
-			functionName: f.functionName,
-			file: f.file,
-			line: f.line,
-			column: f.column,
-			isAsync: f.isAsync,
-		}));
-		console.log(formatStack(frames));
-	}
-
-	// Breakpoints section
-	if ((showAll || stateArgs.breakpoints) && data.breakpointCount !== undefined) {
-		console.log("");
-		console.log(`Breakpoints: ${data.breakpointCount} active`);
-	}
+	printState(data);
 
 	return 0;
 });

package/src/commands/status.ts

@@ -1,12 +1,13 @@
 import { registerCommand } from "../cli/registry.ts";
 import { DaemonClient } from "../daemon/client.ts";
+import { shortPath } from "../formatter/path.ts";
 
 registerCommand("status", 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;
 	}
 
@@ -47,7 +48,7 @@ registerCommand("status", async (args) => {
 
 		if (data.pauseInfo) {
 			const loc = data.pauseInfo.url
-				? `${data.pauseInfo.url}:${data.pauseInfo.line}${data.pauseInfo.column !== undefined ? `:${data.pauseInfo.column}` : ""}`
+				? `${shortPath(data.pauseInfo.url)}:${data.pauseInfo.line}${data.pauseInfo.column !== undefined ? `:${data.pauseInfo.column}` : ""}`
 				: "unknown";
 			console.log(`  Paused: ${data.pauseInfo.reason} at ${loc}`);
 		}

package/src/commands/step.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("step", 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;
 	}
 
@@ -24,27 +25,13 @@ registerCommand("step", 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/vars.ts

@@ -8,7 +8,7 @@ registerCommand("vars", 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;
 	}
 
@@ -45,6 +45,7 @@ registerCommand("vars", async (args) => {
 		name: string;
 		type: string;
 		value: string;
+		scope: string;
 	}>;
 
 	if (args.global.json) {
@@ -61,6 +62,7 @@ registerCommand("vars", async (args) => {
 		ref: v.ref,
 		name: v.name,
 		value: v.value,
+		scope: v.scope,
 	}));
 	const formatted = formatVariables(vars);
 	if (formatted) {

package/src/daemon/entry.ts

@@ -6,7 +6,7 @@ import { DebugSession } from "./session.ts";
 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>]");
+	console.error("Usage: agent-dbg --daemon <session> [--timeout <seconds>]");
 	process.exit(1);
 }
 
@@ -52,32 +52,37 @@ server.onRequest(async (req: DaemonRequest): Promise<DaemonResponse> => {
 
 		case "continue": {
 			await debugSession.continue();
-			return { ok: true, data: debugSession.getStatus() };
+			const stateAfter = await debugSession.buildState();
+			return { ok: true, data: stateAfter };
 		}
 
 		case "step": {
 			const { mode = "over" } = req.args;
 			await debugSession.step(mode);
-			return { ok: true, data: debugSession.getStatus() };
+			const stateAfter = await debugSession.buildState();
+			return { ok: true, data: stateAfter };
 		}
 
 		case "pause": {
 			await debugSession.pause();
-			return { ok: true, data: debugSession.getStatus() };
+			const stateAfter = await debugSession.buildState();
+			return { ok: true, data: stateAfter };
 		}
 
 		case "run-to": {
 			const { file, line } = req.args;
 			await debugSession.runTo(file, line);
-			return { ok: true, data: debugSession.getStatus() };
+			const stateAfter = await debugSession.buildState();
+			return { ok: true, data: stateAfter };
 		}
 
 		case "break": {
-			const { file, line, condition, hitCount, urlRegex } = req.args;
+			const { file, line, condition, hitCount, urlRegex, column } = req.args;
 			const bpResult = await debugSession.setBreakpoint(file, line, {
 				condition,
 				hitCount,
 				urlRegex,
+				column,
 			});
 			return { ok: true, data: bpResult };
 		}
@@ -229,6 +234,11 @@ server.onRequest(async (req: DaemonRequest): Promise<DaemonResponse> => {
 			return { ok: true, data: "disabled" };
 		}
 
+		case "restart": {
+			const result = await debugSession.restart();
+			return { ok: true, data: result };
+		}
+
 		case "stop":
 			await debugSession.stop();
 			setTimeout(() => {

package/src/daemon/paths.ts

@@ -4,10 +4,10 @@ import { join } from "node:path";
 export function getSocketDir(): string {
 	const xdgRuntime = process.env.XDG_RUNTIME_DIR;
 	if (xdgRuntime) {
-		return join(xdgRuntime, "ndbg");
+		return join(xdgRuntime, "agent-dbg");
 	}
 	const tmpdir = process.env.TMPDIR || "/tmp";
-	return join(tmpdir, `ndbg-${process.getuid?.() ?? 0}`);
+	return join(tmpdir, `agent-dbg-${process.getuid?.() ?? 0}`);
 }
 
 export function getSocketPath(session: string): string {
@@ -18,6 +18,10 @@ export function getLockPath(session: string): string {
 	return join(getSocketDir(), `${session}.lock`);
 }
 
+export function getLogPath(session: string): string {
+	return join(getSocketDir(), `${session}.cdp.log`);
+}
+
 export function ensureSocketDir(): void {
 	const dir = getSocketDir();
 	if (!existsSync(dir)) {

package/src/daemon/server.ts

@@ -106,7 +106,7 @@ export class DaemonServer {
 				? {
 						ok: false,
 						error: `Unknown command: ${cmd}`,
-						suggestion: "-> Try: ndbg --help",
+						suggestion: "-> Try: agent-dbg --help",
 					}
 				: {
 						ok: false,

package/src/daemon/session-breakpoints.ts

@@ -5,7 +5,7 @@ export async function setBreakpoint(
 	session: DebugSession,
 	file: string,
 	line: number,
-	options?: { condition?: string; hitCount?: number; urlRegex?: string },
+	options?: { condition?: string; hitCount?: number; urlRegex?: string; column?: number },
 ): Promise<{ ref: string; location: { url: string; line: number; column?: number } }> {
 	if (!session.cdp) {
 		throw new Error("No active debug session");
@@ -17,14 +17,16 @@ export async function setBreakpoint(
 	let originalFile: string | null = null;
 	let originalLine: number | null = null;
 	let actualLine = line;
+	let actualColumn: number | undefined = options?.column !== undefined ? options.column - 1 : undefined; // user column is 1-based
 	let actualFile = file;
 
 	if (!options?.urlRegex) {
-		const generated = session.sourceMapResolver.toGenerated(file, line, 0);
+		const generated = session.sourceMapResolver.toGenerated(file, line, actualColumn ?? 0);
 		if (generated) {
 			originalFile = file;
 			originalLine = line;
 			actualLine = generated.line;
+			actualColumn = generated.column;
 			// Find the URL of the generated script
 			const scriptInfo = session.scripts.get(generated.scriptId);
 			if (scriptInfo) {
@@ -36,6 +38,9 @@ export async function setBreakpoint(
 	const params: Protocol.Debugger.SetBreakpointByUrlRequest = {
 		lineNumber: actualLine - 1, // CDP uses 0-based lines
 	};
+	if (actualColumn !== undefined) {
+		params.columnNumber = actualColumn;
+	}
 
 	let url: string | null = null;
 	if (options?.urlRegex) {

package/src/daemon/session-inspection.ts

@@ -54,7 +54,7 @@ export async function evalExpression(
 		for (const ref of refMatches) {
 			const remoteId = session.refs.resolveId(ref);
 			if (remoteId) {
-				const argName = `__ndbg_ref_${ref.slice(1)}`;
+				const argName = `__adbg_ref_${ref.slice(1)}`;
 				resolvedExpression = resolvedExpression.replace(ref, argName);
 				refEntries.push({
 					ref,
@@ -139,7 +139,7 @@ export async function evalExpression(
 export async function getVars(
 	session: DebugSession,
 	options: { frame?: string; names?: string[]; allScopes?: boolean } = {},
-): Promise<Array<{ ref: string; name: string; type: string; value: string }>> {
+): Promise<Array<{ ref: string; name: string; type: string; value: string; scope: string }>> {
 	if (!session.cdp) {
 		throw new Error("No active debug session");
 	}
@@ -174,19 +174,14 @@ export async function getVars(
 		name: string;
 		type: string;
 		value: string;
+		scope: string;
 	}> = [];
 
 	for (const scope of scopeChain) {
 		const scopeType = scope.type;
 
-		// Include local, module, block, and script scopes by default.
-		// Include closure scope only with allScopes. Always skip global.
-		const includeScope =
-			scopeType === "local" ||
-			scopeType === "module" ||
-			scopeType === "block" ||
-			scopeType === "script" ||
-			(options.allScopes && scopeType === "closure");
+		// Show all scopes except "global" (too noisy — thousands of entries)
+		const includeScope = scopeType !== "global";
 
 		if (includeScope) {
 			const scopeObj = scope.object;
@@ -223,6 +218,7 @@ export async function getVars(
 					name: propName,
 					type: propValue.type,
 					value: formatValue(propValue),
+					scope: scopeType,
 				});
 			}
 		}

package/src/daemon/session-state.ts

@@ -198,13 +198,13 @@ export async function buildState(
 		try {
 			const scopeChain = targetFrame.scopeChain;
 			if (scopeChain) {
-				const locals: Array<{ ref: string; name: string; value: string }> = [];
+				const vars: Array<{ ref: string; name: string; value: string; scope: string }> = [];
 
 				for (const scope of scopeChain) {
 					const scopeType = scope.type;
 
-					// By default only show "local" scope; with --all-scopes include "closure" too
-					if (scopeType === "local" || (options.allScopes && scopeType === "closure")) {
+					// Show all scopes except "global" (too noisy — thousands of entries)
+					if (scopeType !== "global") {
 						const scopeObj = scope.object;
 						const objectId = scopeObj.objectId;
 						if (!objectId) continue;
@@ -229,10 +229,11 @@ export async function buildState(
 							const remoteId = propValue.objectId ?? `primitive:${propName}`;
 							const ref = session.refs.addVar(remoteId as string, propName);
 
-							locals.push({
+							vars.push({
 								ref,
 								name: propName,
 								value: formatValue(propValue),
+								scope: scopeType,
 							});
 						}
 					}
@@ -241,7 +242,7 @@ export async function buildState(
 					if (scopeType === "global") continue;
 				}
 
-				snapshot.locals = locals;
+				snapshot.vars = vars;
 			}
 		} catch {
 			// Variables not available

package/src/daemon/session.ts

@@ -1,10 +1,12 @@
 import type { Subprocess } from "bun";
 import type Protocol from "devtools-protocol/types/protocol.js";
 import { CdpClient } from "../cdp/client.ts";
+import { CdpLogger } from "../cdp/logger.ts";
 import type { RemoteObject } from "../formatter/values.ts";
 import { formatValue } from "../formatter/values.ts";
 import { RefTable } from "../refs/ref-table.ts";
 import { SourceMapResolver } from "../sourcemap/resolver.ts";
+import { ensureSocketDir, getLogPath } from "./paths.ts";
 import {
 	addBlackbox as addBlackboxImpl,
 	listBlackbox as listBlackboxImpl,
@@ -73,7 +75,7 @@ export interface StateSnapshot {
 	reason?: string;
 	location?: { url: string; line: number; column?: number };
 	source?: { lines: Array<{ line: number; text: string; current?: boolean }> };
-	locals?: Array<{ ref: string; name: string; value: string }>;
+	vars?: Array<{ ref: string; name: string; value: string; scope: string }>;
 	stack?: Array<{
 		ref: string;
 		functionName: string;
@@ -152,9 +154,14 @@ export class DebugSession {
 	blackboxPatterns: string[] = [];
 	disabledBreakpoints: Map<string, { breakpointId: string; meta: Record<string, unknown> }> =
 		new Map();
+	launchCommand: string[] | null = null;
+	launchOptions: { brk?: boolean; port?: number } | null = null;
+	cdpLogger: CdpLogger;
 
 	constructor(session: string) {
 		this.session = session;
+		ensureSocketDir();
+		this.cdpLogger = new CdpLogger(getLogPath(session));
 	}
 
 	// ── Session lifecycle ─────────────────────────────────────────────
@@ -171,6 +178,9 @@ export class DebugSession {
 			throw new Error("Command array must not be empty");
 		}
 
+		this.launchCommand = command;
+		this.launchOptions = options;
+
 		const brk = options.brk ?? true;
 		const port = options.port ?? 0;
 		const inspectFlag = brk ? `--inspect-brk=${port}` : `--inspect=${port}`;
@@ -311,6 +321,16 @@ export class DebugSession {
 		this.sourceMapResolver.clear();
 	}
 
+	async restart(): Promise<LaunchResult> {
+		if (!this.launchCommand) {
+			throw new Error("No previous launch to restart. Use 'launch' first.");
+		}
+		const command = this.launchCommand;
+		const options = this.launchOptions ?? {};
+		await this.stop();
+		return this.launch(command, options);
+	}
+
 	get sessionState(): "idle" | "running" | "paused" {
 		return this.state;
 	}
@@ -653,7 +673,7 @@ export class DebugSession {
 
 	buildBreakpointCondition(condition?: string, hitCount?: number): string | undefined {
 		if (hitCount && hitCount > 0) {
-			const countVar = `__ndbg_bp_count_${Date.now()}`;
+			const countVar = `__adbg_bp_count_${Date.now()}`;
 			const hitExpr = `(typeof ${countVar} === "undefined" ? (${countVar} = 1) : ++${countVar}) >= ${hitCount}`;
 			if (condition) {
 				return `(${hitExpr}) && (${condition})`;
@@ -721,7 +741,7 @@ export class DebugSession {
 	}
 
 	private async connectCdp(wsUrl: string): Promise<void> {
-		const cdp = await CdpClient.connect(wsUrl);
+		const cdp = await CdpClient.connect(wsUrl, this.cdpLogger);
 		this.cdp = cdp;
 
 		// Set up event handlers before enabling domains so we don't miss any events

package/src/formatter/logs.ts

@@ -0,0 +1,110 @@
+import type { CdpLogEntry } from "../cdp/logger.ts";
+
+function formatTime(ts: number): string {
+	const d = new Date(ts);
+	const h = String(d.getHours()).padStart(2, "0");
+	const m = String(d.getMinutes()).padStart(2, "0");
+	const s = String(d.getSeconds()).padStart(2, "0");
+	const ms = String(d.getMilliseconds()).padStart(3, "0");
+	return `${h}:${m}:${s}.${ms}`;
+}
+
+function truncate(s: string, max: number): string {
+	return s.length > max ? `${s.slice(0, max - 3)}...` : s;
+}
+
+type Summarizer = (entry: CdpLogEntry) => string;
+
+const eventSummarizers: Record<string, Summarizer> = {
+	"Debugger.scriptParsed": (e) => {
+		const p = e.params ?? {};
+		const url = (p.url as string) || "(anonymous)";
+		const lines = p.endLine != null ? Number(p.endLine) + 1 : "?";
+		const hasMap = p.sourceMapURL ? "yes" : "no";
+		return `scriptId=${p.scriptId} url=${url} lines=${lines} sourceMap=${hasMap}`;
+	},
+	"Debugger.paused": (e) => {
+		const p = e.params ?? {};
+		const reason = (p.reason as string) ?? "unknown";
+		const frames = p.callFrames as Array<Record<string, unknown>> | undefined;
+		const top = frames?.[0];
+		let loc = "";
+		if (top) {
+			const location = top.location as Record<string, unknown> | undefined;
+			const url = (top.url as string) || `script:${location?.scriptId}`;
+			loc = ` location=${url}:${location?.lineNumber}`;
+		}
+		const count = frames?.length ?? 0;
+		return `reason=${reason}${loc} callFrames=${count}`;
+	},
+	"Debugger.resumed": () => "",
+	"Runtime.consoleAPICalled": (e) => {
+		const p = e.params ?? {};
+		const type = (p.type as string) ?? "log";
+		const args = p.args as Array<unknown> | undefined;
+		return `type=${type} args=${args?.length ?? 0}`;
+	},
+	"Runtime.exceptionThrown": (e) => {
+		const p = e.params ?? {};
+		const detail = p.exceptionDetails as Record<string, unknown> | undefined;
+		const text = (detail?.text as string) ?? "";
+		return truncate(text, 80);
+	},
+	"Runtime.executionContextCreated": (e) => {
+		const p = e.params ?? {};
+		const ctx = p.context as Record<string, unknown> | undefined;
+		return `contextId=${ctx?.id}`;
+	},
+	"Runtime.executionContextDestroyed": (e) => {
+		const p = e.params ?? {};
+		return `executionContextId=${p.executionContextId}`;
+	},
+};
+
+const responseSummarizers: Record<string, Summarizer> = {
+	"Debugger.setBreakpointByUrl": (e) => {
+		const r = (e.result ?? {}) as Record<string, unknown>;
+		return `breakpointId=${r.breakpointId}`;
+	},
+	"Debugger.setBreakpoint": (e) => {
+		const r = (e.result ?? {}) as Record<string, unknown>;
+		return `breakpointId=${r.breakpointId}`;
+	},
+};
+
+function summarizeParams(entry: CdpLogEntry): string {
+	const p = entry.params;
+	if (!p || Object.keys(p).length === 0) return "";
+	return truncate(JSON.stringify(p), 120);
+}
+
+function summarizeResult(entry: CdpLogEntry): string {
+	const summarizer = responseSummarizers[entry.method];
+	if (summarizer) return summarizer(entry);
+	// Don't dump large results by default
+	return "";
+}
+
+export function formatLogEntry(entry: CdpLogEntry): string {
+	const time = `[${formatTime(entry.ts)}]`;
+
+	if (entry.dir === "send") {
+		const params = summarizeParams(entry);
+		return `${time}  -> ${entry.method}${params ? `  ${params}` : ""}`;
+	}
+
+	if (entry.dir === "recv") {
+		const idStr = entry.id != null ? ` #${entry.id}` : "";
+		const msStr = entry.ms != null ? ` (${entry.ms}ms)` : "";
+		if (entry.error) {
+			return `${time}  <- ${entry.method}${idStr}${msStr}  ERROR: ${entry.error.message}`;
+		}
+		const summary = summarizeResult(entry);
+		return `${time}  <- ${entry.method}${idStr}${msStr}${summary ? `  ${summary}` : ""}`;
+	}
+
+	// event
+	const summarizer = eventSummarizers[entry.method];
+	const summary = summarizer ? summarizer(entry) : summarizeParams(entry);
+	return `${time}  <- ${entry.method}${summary ? `  ${summary}` : ""}`;
+}

package/src/formatter/path.ts

@@ -0,0 +1,27 @@
+import { relative } from "node:path";
+
+const cwd = process.cwd();
+
+/** Shorten a file path for display: strip file:// prefix, make relative to cwd. */
+export function shortPath(path: string): string {
+	// Strip file:// protocol
+	if (path.startsWith("file://")) {
+		path = path.slice(7);
+	}
+
+	// Keep node: and other protocol URLs as-is
+	if (path.includes("://") || path.startsWith("node:")) {
+		return path;
+	}
+
+	// Make relative to cwd
+	if (path.startsWith("/")) {
+		const rel = relative(cwd, path);
+		// Only use relative if it's actually shorter and doesn't escape too far
+		if (!rel.startsWith("../../..") && rel.length < path.length) {
+			return rel.startsWith("..") ? rel : `./${rel}`;
+		}
+	}
+
+	return path;
+}

package/src/formatter/stack.ts

@@ -1,3 +1,5 @@
+import { shortPath } from "./path.ts";
+
 export interface StackFrame {
 	ref: string;
 	functionName: string;
@@ -59,10 +61,11 @@ export function formatStack(frames: StackFrame[]): string {
 
 		const ref = frame.ref.padEnd(maxRefLen);
 		const name = frame.functionName.padEnd(maxNameLen);
+		const file = shortPath(frame.file);
 		const loc =
 			frame.column !== undefined
-				? `${frame.file}:${frame.line}:${frame.column}`
-				: `${frame.file}:${frame.line}`;
+				? `${file}:${frame.line}:${frame.column}`
+				: `${file}:${frame.line}`;
 		outputLines.push(`${ref}  ${name}  ${loc}`);
 	}