agent-dbg 0.1.2 → 0.1.3

package/tests/integration/daemon-logging.test.ts

@@ -0,0 +1,156 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { DaemonLogger } from "../../src/daemon/logger.ts";
+import type { DaemonLogEntry } from "../../src/daemon/logger.ts";
+import { getDaemonLogPath } from "../../src/daemon/paths.ts";
+import { DebugSession } from "../../src/daemon/session.ts";
+
+function readEntries(logPath: string): DaemonLogEntry[] {
+	if (!existsSync(logPath)) return [];
+	const content = readFileSync(logPath, "utf-8");
+	return content
+		.split("\n")
+		.filter((l) => l.trim())
+		.map((l) => JSON.parse(l) as DaemonLogEntry);
+}
+
+function hasEvent(entries: DaemonLogEntry[], event: string): boolean {
+	return entries.some((e) => e.event === event);
+}
+
+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("DaemonLogger integration", () => {
+	test("DaemonLogger writes to daemon.log file", () => {
+		const logPath = join(tmpdir(), `test-daemon-write-${Date.now()}.daemon.log`);
+		try {
+			const logger = new DaemonLogger(logPath);
+			logger.info("test.event", "hello world", { key: "value" });
+
+			const entries = readEntries(logPath);
+			expect(entries).toHaveLength(1);
+			expect(entries[0]!.level).toBe("info");
+			expect(entries[0]!.event).toBe("test.event");
+			expect(entries[0]!.message).toBe("hello world");
+			expect(entries[0]!.data).toEqual({ key: "value" });
+		} finally {
+			if (existsSync(logPath)) unlinkSync(logPath);
+		}
+	});
+
+	test("getDaemonLogPath returns correct path", () => {
+		const path = getDaemonLogPath("my-session");
+		expect(path).toEndWith("/my-session.daemon.log");
+	});
+
+	test("DebugSession logs launch events", async () => {
+		const sessionName = `test-daemon-log-${Date.now()}`;
+		const session = new DebugSession(sessionName);
+		const logPath = getDaemonLogPath(sessionName);
+		try {
+			await session.launch(["node", "tests/fixtures/simple-app.js"], {
+				brk: true,
+			});
+			await waitForState(session, "paused");
+
+			const entries = readEntries(logPath);
+			expect(hasEvent(entries, "child.spawn")).toBe(true);
+			expect(hasEvent(entries, "inspector.detected")).toBe(true);
+			expect(hasEvent(entries, "cdp.connected")).toBe(true);
+		} finally {
+			await session.stop();
+			if (existsSync(logPath)) unlinkSync(logPath);
+		}
+	});
+
+	test("DebugSession logs child stderr", async () => {
+		const sessionName = `test-daemon-stderr-${Date.now()}`;
+		const session = new DebugSession(sessionName);
+		const logPath = getDaemonLogPath(sessionName);
+		try {
+			await session.launch(["node", "tests/fixtures/simple-app.js"], {
+				brk: true,
+			});
+			await waitForState(session, "paused");
+
+			const entries = readEntries(logPath);
+			// The "Debugger listening on..." line comes from child stderr
+			const stderrEntries = entries.filter((e) => e.event === "child.stderr");
+			expect(stderrEntries.length).toBeGreaterThan(0);
+			const hasDebuggerLine = stderrEntries.some((e) =>
+				e.message.includes("Debugger listening on"),
+			);
+			expect(hasDebuggerLine).toBe(true);
+		} finally {
+			await session.stop();
+			if (existsSync(logPath)) unlinkSync(logPath);
+		}
+	});
+
+	test("DebugSession logs inspector URL detection failure", async () => {
+		const sessionName = `test-daemon-fail-${Date.now()}`;
+		const session = new DebugSession(sessionName);
+		const logPath = getDaemonLogPath(sessionName);
+		try {
+			// Use echo (not node), which won't emit an inspector URL
+			await expect(
+				session.launch(["echo", "hello"], { brk: true }),
+			).rejects.toThrow("Failed to detect inspector URL");
+
+			const entries = readEntries(logPath);
+			expect(hasEvent(entries, "child.spawn")).toBe(true);
+			expect(hasEvent(entries, "inspector.failed")).toBe(true);
+			// Should capture the accumulated stderr in the failure entry
+			const failEntry = entries.find((e) => e.event === "inspector.failed");
+			expect(failEntry?.data?.stderr).toBeDefined();
+		} finally {
+			await session.stop();
+			if (existsSync(logPath)) unlinkSync(logPath);
+		}
+	});
+
+	test("DebugSession logs process exit", async () => {
+		const sessionName = `test-daemon-exit-${Date.now()}`;
+		const session = new DebugSession(sessionName);
+		const logPath = getDaemonLogPath(sessionName);
+		try {
+			// Use process.exit() to force the child to terminate.
+			// Node.js waits for the debugger to disconnect before exiting,
+			// so we disconnect CDP after a delay to allow the natural exit.
+			await session.launch(
+				["node", "-e", "setTimeout(() => process.exit(0), 200)"],
+				{ brk: false },
+			);
+
+			// Disconnect CDP so Node.js can actually exit
+			// (Node prints "Waiting for the debugger to disconnect..." otherwise)
+			await Bun.sleep(300);
+			session.cdp?.disconnect();
+
+			// Wait for the child.exit log entry to be written
+			const deadline = Date.now() + 5000;
+			while (Date.now() < deadline) {
+				const entries = readEntries(logPath);
+				if (hasEvent(entries, "child.exit")) break;
+				await Bun.sleep(100);
+			}
+
+			const entries = readEntries(logPath);
+			expect(hasEvent(entries, "child.exit")).toBe(true);
+		} finally {
+			await session.stop();
+			if (existsSync(logPath)) unlinkSync(logPath);
+		}
+	});
+});

package/tests/unit/daemon-logger.test.ts

@@ -0,0 +1,117 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { DaemonLogger } from "../../src/daemon/logger.ts";
+import type { DaemonLogEntry } from "../../src/daemon/logger.ts";
+
+const testDir = tmpdir();
+
+function tempLogPath(): string {
+	return join(testDir, `test-daemon-${Date.now()}-${Math.random().toString(36).slice(2)}.log`);
+}
+
+function readEntries(logPath: string): DaemonLogEntry[] {
+	const content = readFileSync(logPath, "utf-8");
+	return content
+		.split("\n")
+		.filter((l) => l.trim())
+		.map((l) => JSON.parse(l) as DaemonLogEntry);
+}
+
+describe("DaemonLogger", () => {
+	const paths: string[] = [];
+
+	afterEach(() => {
+		for (const p of paths) {
+			if (existsSync(p)) unlinkSync(p);
+		}
+		paths.length = 0;
+	});
+
+	test("truncates on creation", () => {
+		const logPath = tempLogPath();
+		paths.push(logPath);
+		writeFileSync(logPath, "pre-existing content\n");
+
+		new DaemonLogger(logPath);
+
+		const content = readFileSync(logPath, "utf-8");
+		expect(content).toBe("");
+	});
+
+	test("appends JSON lines", () => {
+		const logPath = tempLogPath();
+		paths.push(logPath);
+		const logger = new DaemonLogger(logPath);
+
+		logger.info("event.one", "first message");
+		logger.warn("event.two", "second message");
+		logger.error("event.three", "third message");
+
+		const entries = readEntries(logPath);
+		expect(entries).toHaveLength(3);
+		expect(entries[0]!.event).toBe("event.one");
+		expect(entries[1]!.event).toBe("event.two");
+		expect(entries[2]!.event).toBe("event.three");
+	});
+
+	test("clear() truncates", () => {
+		const logPath = tempLogPath();
+		paths.push(logPath);
+		const logger = new DaemonLogger(logPath);
+
+		logger.info("test", "message");
+		logger.info("test", "another");
+		expect(readEntries(logPath)).toHaveLength(2);
+
+		logger.clear();
+
+		const content = readFileSync(logPath, "utf-8");
+		expect(content).toBe("");
+	});
+
+	test("entries have correct structure", () => {
+		const logPath = tempLogPath();
+		paths.push(logPath);
+		const logger = new DaemonLogger(logPath);
+		const before = Date.now();
+
+		logger.info("child.spawn", "Process spawned", { pid: 1234 });
+
+		const entries = readEntries(logPath);
+		expect(entries).toHaveLength(1);
+		const entry = entries[0]!;
+
+		expect(entry.ts).toBeGreaterThanOrEqual(before);
+		expect(entry.ts).toBeLessThanOrEqual(Date.now());
+		expect(entry.level).toBe("info");
+		expect(entry.event).toBe("child.spawn");
+		expect(entry.message).toBe("Process spawned");
+		expect(entry.data).toEqual({ pid: 1234 });
+	});
+
+	test("debug level works", () => {
+		const logPath = tempLogPath();
+		paths.push(logPath);
+		const logger = new DaemonLogger(logPath);
+
+		logger.debug("test.debug", "debug message");
+
+		const entries = readEntries(logPath);
+		expect(entries).toHaveLength(1);
+		expect(entries[0]!.level).toBe("debug");
+	});
+
+	test("entries without data omit data field", () => {
+		const logPath = tempLogPath();
+		paths.push(logPath);
+		const logger = new DaemonLogger(logPath);
+
+		logger.info("test", "no data");
+
+		const entries = readEntries(logPath);
+		expect(entries).toHaveLength(1);
+		expect(entries[0]!.data).toBeUndefined();
+	});
+});

package/tests/unit/daemon.test.ts

@@ -251,6 +251,66 @@ describe("dead socket detection", () => {
 	});
 });
 
+describe("stale daemon detection (Docker-style PID check)", () => {
+	test("isRunning returns false when socket exists but no lock file", () => {
+		const session = testSession("nolck");
+		const socketPath = getSocketPath(session);
+
+		writeFileSync(socketPath, "");
+
+		expect(DaemonClient.isRunning(session)).toBe(false);
+	});
+
+	test("isRunning returns false when socket+lock exist but PID is dead", () => {
+		const session = testSession("dpid");
+		const socketPath = getSocketPath(session);
+		const lockPath = getLockPath(session);
+
+		writeFileSync(socketPath, "");
+		writeFileSync(lockPath, "999999"); // non-existent PID
+
+		expect(DaemonClient.isRunning(session)).toBe(false);
+	});
+
+	test("isRunning returns true when daemon is actually alive", async () => {
+		const session = testSession("alive");
+		const server = new DaemonServer(session, { idleTimeout: 60 });
+		server.onRequest(async () => ({ ok: true }));
+		await server.start();
+
+		try {
+			expect(DaemonClient.isRunning(session)).toBe(true);
+		} finally {
+			await server.stop();
+		}
+	});
+
+	test("isRunning returns false when no socket exists", () => {
+		const session = testSession("nosck");
+		expect(DaemonClient.isRunning(session)).toBe(false);
+	});
+
+	test("cleanStaleFiles removes orphaned socket and lock", () => {
+		const session = testSession("clnst");
+		const socketPath = getSocketPath(session);
+		const lockPath = getLockPath(session);
+
+		writeFileSync(socketPath, "");
+		writeFileSync(lockPath, "999999");
+
+		DaemonClient.cleanStaleFiles(session);
+
+		expect(existsSync(socketPath)).toBe(false);
+		expect(existsSync(lockPath)).toBe(false);
+	});
+
+	test("cleanStaleFiles is safe when files don't exist", () => {
+		const session = testSession("clnno");
+		// Should not throw
+		DaemonClient.cleanStaleFiles(session);
+	});
+});
+
 describe("listSessions", () => {
 	test("returns active sessions", async () => {
 		const session1 = testSession("la");