agent-dbg 0.1.0

package/tests/integration/source.test.ts

@@ -0,0 +1,209 @@
+import { describe, expect, test } from "bun:test";
+import { DebugSession } from "../../src/daemon/session.ts";
+
+/**
+ * Polls until the session reaches the expected state, or times out.
+ */
+async function waitForState(
+	session: DebugSession,
+	state: "idle" | "running" | "paused",
+	timeoutMs = 5000,
+): Promise<void> {
+	const deadline = Date.now() + timeoutMs;
+	while (session.sessionState !== state && Date.now() < deadline) {
+		await Bun.sleep(50);
+	}
+}
+
+describe("Inspection commands", () => {
+	test("getSource returns lines around pause location with current marker", async () => {
+		const session = new DebugSession("test-source-basic");
+		try {
+			await session.launch(["node", "tests/fixtures/step-app.js"], { brk: true });
+			await waitForState(session, "paused");
+			expect(session.sessionState).toBe("paused");
+
+			const result = await session.getSource();
+			expect(result.url).toBeDefined();
+			expect(result.lines.length).toBeGreaterThan(0);
+
+			// There should be exactly one line marked as current
+			const currentLines = result.lines.filter((l) => l.current === true);
+			expect(currentLines.length).toBe(1);
+
+			// All lines should have line numbers and text
+			for (const line of result.lines) {
+				expect(typeof line.line).toBe("number");
+				expect(typeof line.text).toBe("string");
+			}
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("getSource with file option shows source of specified file", async () => {
+		const session = new DebugSession("test-source-file");
+		try {
+			await session.launch(["node", "tests/fixtures/step-app.js"], { brk: true });
+			await waitForState(session, "paused");
+			expect(session.sessionState).toBe("paused");
+
+			const result = await session.getSource({ file: "step-app.js" });
+			expect(result.url).toContain("step-app.js");
+			expect(result.lines.length).toBeGreaterThan(0);
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("getSource with all option returns entire file", async () => {
+		const session = new DebugSession("test-source-all");
+		try {
+			await session.launch(["node", "tests/fixtures/step-app.js"], { brk: true });
+			await waitForState(session, "paused");
+			expect(session.sessionState).toBe("paused");
+
+			const result = await session.getSource({ all: true });
+			expect(result.lines.length).toBeGreaterThan(0);
+
+			// step-app.js has 13 lines of content; with all, we should see all of them
+			// The file has content on lines including function helper, const a, etc.
+			expect(result.lines.length).toBeGreaterThanOrEqual(10);
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("getScripts lists loaded scripts including step-app.js", async () => {
+		const session = new DebugSession("test-scripts-list");
+		try {
+			await session.launch(["node", "tests/fixtures/step-app.js"], { brk: true });
+			await waitForState(session, "paused");
+			expect(session.sessionState).toBe("paused");
+
+			const scripts = session.getScripts();
+			expect(scripts.length).toBeGreaterThan(0);
+
+			// step-app.js should be in the list
+			const stepApp = scripts.find((s) => s.url.includes("step-app.js"));
+			expect(stepApp).toBeDefined();
+			expect(stepApp!.scriptId).toBeDefined();
+			expect(stepApp!.url).toContain("step-app.js");
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("getScripts with filter narrows results", async () => {
+		const session = new DebugSession("test-scripts-filter");
+		try {
+			await session.launch(["node", "tests/fixtures/step-app.js"], { brk: true });
+			await waitForState(session, "paused");
+			expect(session.sessionState).toBe("paused");
+
+			const allScripts = session.getScripts();
+			const filtered = session.getScripts("step-app");
+
+			// Filtered should contain step-app.js
+			expect(filtered.length).toBeGreaterThan(0);
+			const stepApp = filtered.find((s) => s.url.includes("step-app.js"));
+			expect(stepApp).toBeDefined();
+
+			// Filtered should be a subset of all scripts
+			expect(filtered.length).toBeLessThanOrEqual(allScripts.length);
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("getStack returns stack frames with refs and correct format", async () => {
+		const session = new DebugSession("test-stack-basic");
+		try {
+			await session.launch(["node", "tests/fixtures/step-app.js"], { brk: true });
+			await waitForState(session, "paused");
+			expect(session.sessionState).toBe("paused");
+
+			const stack = session.getStack();
+			expect(stack.length).toBeGreaterThan(0);
+
+			// Each frame should have ref, functionName, file, line
+			for (const frame of stack) {
+				expect(frame.ref).toMatch(/^@f\d+$/);
+				expect(typeof frame.functionName).toBe("string");
+				expect(typeof frame.file).toBe("string");
+				expect(typeof frame.line).toBe("number");
+				expect(frame.line).toBeGreaterThan(0); // 1-based
+			}
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("getStack while inside a function shows multiple frames", async () => {
+		const session = new DebugSession("test-stack-nested");
+		try {
+			await session.launch(["node", "tests/fixtures/step-app.js"], { brk: true });
+			await waitForState(session, "paused");
+
+			// Step to the helper() call and step into it
+			let currentLine = session.getStatus().pauseInfo?.line ?? 0;
+			while (currentLine < 10 && session.sessionState === "paused") {
+				await session.step("over");
+				currentLine = session.getStatus().pauseInfo?.line ?? currentLine;
+			}
+
+			await session.step("into");
+			const line = session.getStatus().pauseInfo?.line;
+			if (line !== undefined && line >= 10) {
+				await session.step("into");
+			}
+
+			expect(session.sessionState).toBe("paused");
+
+			const stack = session.getStack();
+			// Should have at least 2 frames: helper + main module
+			expect(stack.length).toBeGreaterThanOrEqual(2);
+
+			// Top frame should be the helper function
+			const topFrame = stack[0];
+			expect(topFrame).toBeDefined();
+			expect(topFrame!.functionName).toBe("helper");
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("searchInScripts finds a string in step-app.js", async () => {
+		const session = new DebugSession("test-search-basic");
+		try {
+			await session.launch(["node", "tests/fixtures/step-app.js"], { brk: true });
+			await waitForState(session, "paused");
+			expect(session.sessionState).toBe("paused");
+
+			const results = await session.searchInScripts("helper");
+			expect(results.length).toBeGreaterThan(0);
+
+			// At least one match should be in step-app.js
+			const stepAppMatch = results.find((r) => r.url.includes("step-app.js"));
+			expect(stepAppMatch).toBeDefined();
+			expect(stepAppMatch!.line).toBeGreaterThan(0);
+			expect(stepAppMatch!.content).toContain("helper");
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("searchInScripts with no matches returns empty array", async () => {
+		const session = new DebugSession("test-search-empty");
+		try {
+			await session.launch(["node", "tests/fixtures/step-app.js"], { brk: true });
+			await waitForState(session, "paused");
+			expect(session.sessionState).toBe("paused");
+
+			const results = await session.searchInScripts("xyzzy_nonexistent_string_12345");
+			expect(results.length).toBe(0);
+		} finally {
+			await session.stop();
+		}
+	});
+});

package/tests/integration/sourcemap.test.ts

@@ -0,0 +1,214 @@
+import { describe, expect, test } from "bun:test";
+import { DebugSession } from "../../src/daemon/session.ts";
+
+async function waitForState(
+	session: DebugSession,
+	state: "idle" | "running" | "paused",
+	timeoutMs = 5000,
+): Promise<void> {
+	const deadline = Date.now() + timeoutMs;
+	while (session.sessionState !== state && Date.now() < deadline) {
+		await Bun.sleep(50);
+	}
+}
+
+describe("Source map integration", () => {
+	test("stack trace shows .ts paths after source map resolution", async () => {
+		const session = new DebugSession("test-sm-stack");
+		try {
+			await session.launch(["node", "tests/fixtures/ts-app/dist/app.js"], { brk: true });
+			await waitForState(session, "paused");
+			expect(session.sessionState).toBe("paused");
+
+			// Wait a moment for source maps to load
+			await Bun.sleep(100);
+
+			// Set breakpoint inside the greet function (line 8 of app.ts)
+			const bp = await session.setBreakpoint("app.ts", 8);
+			expect(bp.ref).toMatch(/^BP#\d+$/);
+
+			// Continue to hit the breakpoint
+			await session.continue();
+			await waitForState(session, "paused");
+			expect(session.sessionState).toBe("paused");
+
+			const stack = session.getStack();
+			expect(stack.length).toBeGreaterThan(0);
+
+			// Top frame should reference .ts source
+			const topFrame = stack[0];
+			expect(topFrame).toBeDefined();
+			expect(topFrame!.file).toContain("app.ts");
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("setBreakpoint on .ts file works via source map translation", async () => {
+		const session = new DebugSession("test-sm-break");
+		try {
+			await session.launch(["node", "tests/fixtures/ts-app/dist/app.js"], { brk: true });
+			await waitForState(session, "paused");
+
+			// Wait for source maps to load
+			await Bun.sleep(100);
+
+			// Set breakpoint on TS file line (add function at line 13 of app.ts)
+			const bp = await session.setBreakpoint("app.ts", 13);
+			expect(bp.ref).toMatch(/^BP#\d+$/);
+			// The location should report the original .ts file
+			expect(bp.location.url).toContain("app.ts");
+			expect(bp.location.line).toBe(13);
+
+			// Continue and it should actually pause
+			await session.continue();
+			await waitForState(session, "paused");
+			expect(session.sessionState).toBe("paused");
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("getSource shows original TypeScript source with type annotations", async () => {
+		const session = new DebugSession("test-sm-source");
+		try {
+			await session.launch(["node", "tests/fixtures/ts-app/dist/app.js"], { brk: true });
+			await waitForState(session, "paused");
+
+			// Wait for source maps to load
+			await Bun.sleep(100);
+
+			const source = await session.getSource({ file: "app.ts", all: true });
+			expect(source.lines.length).toBeGreaterThan(0);
+
+			// Should contain TypeScript type annotations
+			const allText = source.lines.map((l) => l.text).join("\n");
+			expect(allText).toContain("Person");
+			expect(allText).toContain(": string");
+			expect(allText).toContain(": number");
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("buildState shows source-mapped .ts location", async () => {
+		const session = new DebugSession("test-sm-state");
+		try {
+			await session.launch(["node", "tests/fixtures/ts-app/dist/app.js"], { brk: true });
+			await waitForState(session, "paused");
+
+			// Wait for source maps to load
+			await Bun.sleep(100);
+
+			// Set breakpoint and continue to it
+			await session.setBreakpoint("app.ts", 8);
+			await session.continue();
+			await waitForState(session, "paused");
+
+			const state = await session.buildState();
+			expect(state.status).toBe("paused");
+			expect(state.location).toBeDefined();
+			expect(state.location!.url).toContain("app.ts");
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("buildState source shows TypeScript content", async () => {
+		const session = new DebugSession("test-sm-state-source");
+		try {
+			await session.launch(["node", "tests/fixtures/ts-app/dist/app.js"], { brk: true });
+			await waitForState(session, "paused");
+
+			// Wait for source maps to load
+			await Bun.sleep(100);
+
+			// Set breakpoint and continue to it
+			await session.setBreakpoint("app.ts", 8);
+			await session.continue();
+			await waitForState(session, "paused");
+
+			const state = await session.buildState({ code: true });
+			expect(state.source).toBeDefined();
+			expect(state.source!.lines.length).toBeGreaterThan(0);
+
+			// Source should contain TS type annotations
+			const allText = state.source!.lines.map((l) => l.text).join("\n");
+			expect(allText).toContain("Person");
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("listBreakpoints shows .ts file locations", async () => {
+		const session = new DebugSession("test-sm-breakls");
+		try {
+			await session.launch(["node", "tests/fixtures/ts-app/dist/app.js"], { brk: true });
+			await waitForState(session, "paused");
+
+			// Wait for source maps to load
+			await Bun.sleep(100);
+
+			await session.setBreakpoint("app.ts", 8);
+
+			const bps = session.listBreakpoints();
+			expect(bps.length).toBe(1);
+			const bp = bps[0];
+			expect(bp).toBeDefined();
+			// URL should be the original .ts file
+			expect(bp!.url).toContain("app.ts");
+			expect(bp!.originalUrl).toContain("app.ts");
+			expect(bp!.originalLine).toBe(8);
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("graceful fallback: plain .js files work exactly as before", async () => {
+		const session = new DebugSession("test-sm-fallback");
+		try {
+			await session.launch(["node", "tests/fixtures/simple-app.js"], { brk: true });
+			await waitForState(session, "paused");
+
+			// Set breakpoint on plain JS file — should work as before
+			const bp = await session.setBreakpoint("simple-app.js", 5);
+			expect(bp.ref).toMatch(/^BP#\d+$/);
+			expect(bp.location.url).toContain("simple-app.js");
+
+			await session.continue();
+			await waitForState(session, "paused");
+			expect(session.sessionState).toBe("paused");
+
+			const stack = session.getStack();
+			expect(stack.length).toBeGreaterThan(0);
+			expect(stack[0]!.file).toContain("simple-app.js");
+
+			const state = await session.buildState();
+			expect(state.location!.url).toContain("simple-app.js");
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("source map info is available via resolver", async () => {
+		const session = new DebugSession("test-sm-info");
+		try {
+			await session.launch(["node", "tests/fixtures/ts-app/dist/app.js"], { brk: true });
+			await waitForState(session, "paused");
+
+			// Wait for source maps to load
+			await Bun.sleep(100);
+
+			const infos = session.sourceMapResolver.getAllInfos();
+			expect(infos.length).toBeGreaterThan(0);
+
+			const appInfo = infos.find((i) => i.generatedUrl.includes("app.js"));
+			expect(appInfo).toBeDefined();
+			expect(appInfo!.sources.length).toBeGreaterThan(0);
+			expect(appInfo!.sources.some((s) => s.includes("app.ts"))).toBe(true);
+			expect(appInfo!.hasSourcesContent).toBe(true);
+		} finally {
+			await session.stop();
+		}
+	});
+});

package/tests/integration/state.test.ts

@@ -0,0 +1,208 @@
+import { describe, expect, test } from "bun:test";
+import { DebugSession } from "../../src/daemon/session.ts";
+
+/**
+ * Polls until the session reaches the expected state, or times out.
+ */
+async function waitForState(
+	session: DebugSession,
+	state: "idle" | "running" | "paused",
+	timeoutMs = 2000,
+): Promise<void> {
+	const deadline = Date.now() + timeoutMs;
+	while (session.sessionState !== state && Date.now() < deadline) {
+		await Bun.sleep(50);
+	}
+}
+
+describe("buildState integration", () => {
+	test("state returns source, locals, and stack when paused", async () => {
+		const session = new DebugSession("test-state-full");
+		try {
+			await session.launch(["node", "tests/fixtures/simple-app.js"], {
+				brk: true,
+			});
+			await waitForState(session, "paused");
+
+			const snapshot = await session.buildState();
+
+			expect(snapshot.status).toBe("paused");
+			expect(snapshot.reason).toBeDefined();
+			expect(snapshot.location).toBeDefined();
+			expect(snapshot.location?.line).toBeGreaterThan(0);
+
+			// Source should be present with lines around the current position
+			expect(snapshot.source).toBeDefined();
+			expect(snapshot.source?.lines.length).toBeGreaterThan(0);
+			// At least one line should be marked as current
+			const currentLine = snapshot.source?.lines.find((l) => l.current === true);
+			expect(currentLine).toBeDefined();
+
+			// Stack should be present
+			expect(snapshot.stack).toBeDefined();
+			expect(snapshot.stack?.length).toBeGreaterThan(0);
+			// First frame should have a ref starting with @f
+			const firstFrame = snapshot.stack?.[0];
+			expect(firstFrame?.ref).toMatch(/^@f/);
+			expect(firstFrame?.line).toBeGreaterThan(0);
+
+			// Locals should be present (may be empty at entry point, but the array should exist)
+			expect(snapshot.locals).toBeDefined();
+
+			// Breakpoint count should be present
+			expect(snapshot.breakpointCount).toBeDefined();
+			expect(snapshot.breakpointCount).toBeGreaterThanOrEqual(0);
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("state returns running status when not paused", async () => {
+		const session = new DebugSession("test-state-running");
+		try {
+			await session.launch(["node", "-e", "setTimeout(() => {}, 30000)"], {
+				brk: false,
+			});
+
+			const snapshot = await session.buildState();
+
+			expect(snapshot.status).toBe("running");
+			// When running, no source/locals/stack should be present
+			expect(snapshot.source).toBeUndefined();
+			expect(snapshot.locals).toBeUndefined();
+			expect(snapshot.stack).toBeUndefined();
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("state with vars filter returns only locals", async () => {
+		const session = new DebugSession("test-state-vars");
+		try {
+			await session.launch(["node", "tests/fixtures/simple-app.js"], {
+				brk: true,
+			});
+			await waitForState(session, "paused");
+
+			const snapshot = await session.buildState({ vars: true });
+
+			expect(snapshot.status).toBe("paused");
+			// Locals should be present
+			expect(snapshot.locals).toBeDefined();
+			// Source and stack should NOT be present (filtered out)
+			expect(snapshot.source).toBeUndefined();
+			expect(snapshot.stack).toBeUndefined();
+			expect(snapshot.breakpointCount).toBeUndefined();
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("state with stack filter returns only stack", async () => {
+		const session = new DebugSession("test-state-stack");
+		try {
+			await session.launch(["node", "tests/fixtures/simple-app.js"], {
+				brk: true,
+			});
+			await waitForState(session, "paused");
+
+			const snapshot = await session.buildState({ stack: true });
+
+			expect(snapshot.status).toBe("paused");
+			// Stack should be present
+			expect(snapshot.stack).toBeDefined();
+			expect(snapshot.stack?.length).toBeGreaterThan(0);
+			// Source, locals, and breakpoints should NOT be present (filtered out)
+			expect(snapshot.source).toBeUndefined();
+			expect(snapshot.locals).toBeUndefined();
+			expect(snapshot.breakpointCount).toBeUndefined();
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("state with code filter returns only source", async () => {
+		const session = new DebugSession("test-state-code");
+		try {
+			await session.launch(["node", "tests/fixtures/simple-app.js"], {
+				brk: true,
+			});
+			await waitForState(session, "paused");
+
+			const snapshot = await session.buildState({ code: true });
+
+			expect(snapshot.status).toBe("paused");
+			// Source should be present
+			expect(snapshot.source).toBeDefined();
+			expect(snapshot.source?.lines.length).toBeGreaterThan(0);
+			// Locals, stack, and breakpoints should NOT be present (filtered out)
+			expect(snapshot.locals).toBeUndefined();
+			expect(snapshot.stack).toBeUndefined();
+			expect(snapshot.breakpointCount).toBeUndefined();
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("state returns idle status when no target", async () => {
+		const session = new DebugSession("test-state-idle");
+		const snapshot = await session.buildState();
+		expect(snapshot.status).toBe("idle");
+	});
+
+	test("state assigns refs to variables and frames", async () => {
+		const session = new DebugSession("test-state-refs");
+		try {
+			await session.launch(["node", "tests/fixtures/simple-app.js"], {
+				brk: true,
+			});
+			await waitForState(session, "paused");
+
+			const snapshot = await session.buildState();
+
+			// Check that variable refs are assigned
+			if (snapshot.locals && snapshot.locals.length > 0) {
+				const firstLocal = snapshot.locals[0];
+				expect(firstLocal?.ref).toMatch(/^@v\d+$/);
+				expect(firstLocal?.name).toBeDefined();
+				expect(firstLocal?.value).toBeDefined();
+
+				// The ref should be resolvable in the ref table
+				const entry = session.refs.resolve(firstLocal?.ref ?? "");
+				expect(entry).toBeDefined();
+			}
+
+			// Check that frame refs are assigned
+			if (snapshot.stack && snapshot.stack.length > 0) {
+				const firstFrame = snapshot.stack[0];
+				expect(firstFrame?.ref).toMatch(/^@f\d+$/);
+
+				// The ref should be resolvable in the ref table
+				const entry = session.refs.resolve(firstFrame?.ref ?? "");
+				expect(entry).toBeDefined();
+			}
+		} finally {
+			await session.stop();
+		}
+	});
+
+	test("state with custom lines context", async () => {
+		const session = new DebugSession("test-state-lines");
+		try {
+			await session.launch(["node", "tests/fixtures/simple-app.js"], {
+				brk: true,
+			});
+			await waitForState(session, "paused");
+
+			// Request more context lines
+			const snapshot = await session.buildState({ code: true, lines: 5 });
+
+			expect(snapshot.source).toBeDefined();
+			// With 5 lines context, we should get up to 11 lines (5 above + current + 5 below)
+			// but may be fewer if near the start/end of file
+			expect(snapshot.source?.lines.length).toBeGreaterThan(0);
+		} finally {
+			await session.stop();
+		}
+	});
+});