import { request } from "node:http"; import { SessionManager } from "@earendil-works/pi-coding-agent"; import { describe, expect, it } from "vitest"; import { buildInspectorData, startInspector } from "../inspector.ts"; function get( url: string, options: { method?: string; headers?: Record } = {}, ) { return new Promise<{ status: number; headers: import("node:http").IncomingHttpHeaders; body: string; }>((resolve, reject) => { const req = request(url, options, (res) => { let body = ""; res.setEncoding("utf8"); res.on("data", (chunk: string) => { body += chunk; }); res.on("end", () => resolve({ status: res.statusCode ?? 0, headers: res.headers, body }), ); }); req.on("error", reject); req.end(); }); } describe("inspector", () => { it("does not mistake a literal truncation marker for clipping", async () => { const manager = SessionManager.inMemory(); manager.appendCustomEntry("marker", "[truncated]"); const result = await buildInspectorData( { cwd: "/", sessionManager: manager }, [], ); expect(result.entries[0]?.previewTruncated).toBe(false); expect(result.warnings).toEqual([]); }); it("streams authenticated full entry details", async () => { const manager = SessionManager.inMemory(); const content = "long 😀".repeat(30_000); const id = manager.appendMessage({ role: "user", content, timestamp: 1 }); const inspector = await startInspector( async () => await buildInspectorData({ cwd: "/", sessionManager: manager }, []), (id) => manager.getEntry(id), ); try { for (const view of ["text", "json"]) { const url = `${inspector.url}entry/${id}/${view}`; const response = await get(url); expect(response.status).toBe(200); expect(response.headers["content-type"]).toContain( "application/x-ndjson", ); const events = response.body .trim() .split("\n") .map((line) => JSON.parse(line)); expect(events.at(-1)).toEqual({ type: "end" }); const text = events .filter((event) => event.type === "text") .map((event) => event.text) .join(""); if (view === "json") expect(JSON.parse(text).message.content).toBe(content); else expect(text).toBe(content); expect( (await get(url, { headers: { origin: "https://evil.invalid" } })) .status, ).toBe(403); expect((await get(url, { method: "POST" })).status).toBe(405); } expect((await get(`${inspector.url}entry/missing/text`)).status).toBe( 404, ); expect((await get(`${inspector.url}entry/${id}/missing`)).status).toBe( 404, ); expect( (await get(new URL(`/entry/${id}/text`, inspector.url).href)).status, ).toBe(404); } finally { await inspector.close(); } }); it("projects the full tree, sanitizes payloads, preserves usage and snapshots", async () => { const manager = SessionManager.inMemory("/project"); const first = manager.appendMessage({ role: "user", content: [ { type: "text", text: "hello" }, { type: "image", data: "secret-base64", mimeType: "image/png" }, ], timestamp: 1, }); const customId = manager.appendCustomEntry("unknown", { nested: "preserved", signature: "secret-signature", }); manager.branch(first); const usageEntry = manager.appendUsage("test", "provider", "model", { input: 0, output: 2, cacheRead: 3, cacheWrite: 4, totalTokens: 9, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0.5 }, }); const prompts = [ { id: 1, timestamp: "now", entryId: first, prompt: "", grouped: "group", }, ]; const data = await buildInspectorData( { cwd: "/project", sessionManager: manager }, prompts, [], undefined, { branch: "all" }, ); const user = data.entries.find((entry) => entry.id === first)!; const custom = data.entries.find((entry) => entry.id === customId)!; const usage = data.entries.find((entry) => entry.id === usageEntry.id)!; expect(data.entries).toHaveLength(3); expect([user, custom, usage].map((entry) => entry.onBranch)).toEqual([ true, false, true, ]); expect(user.images).toEqual([ { index: 1, mimeType: "image/png", bytes: null, width: null, height: null, }, ]); expect(user.raw).not.toContain("secret-base64"); expect(custom.raw).toContain("preserved"); expect(JSON.parse(custom.raw).data.signature).toBe("secret-signature"); expect(usage.usage).toEqual({ input: 0, output: 2, cacheRead: 3, cacheWrite: 4, totalTokens: 9, cost: 0.5, costSource: "recorded", costBreakdown: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0.5, }, catalogCost: null, }); expect(data.prompts).toEqual([]); }); it("projects catalog prices independently from recorded usage and source bytes", async () => { const manager = SessionManager.inMemory(); manager.appendMessage({ role: "assistant", api: "openai", provider: "p", model: "m", timestamp: 1000, stopReason: "stop", content: [{ type: "text", text: "é".repeat(150_000) }], usage: { input: 1_000_000, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 1_000_000, cost: { input: 9, output: 0, cacheRead: 0, cacheWrite: 0, total: 9 }, }, }); const [entry] = ( await buildInspectorData( { cwd: "/", sessionManager: manager }, [], [], (provider, model) => provider === "p" && model === "m" ? { input: 2, output: 3, cacheRead: 4, cacheWrite: 5 } : undefined, ) ).entries; expect(entry).toMatchObject({ provider: "p", model: "m", metrics: { textBytes: 300_000, durationMs: null, startedAt: "1970-01-01T00:00:01.000Z", }, usage: { cost: 9, costSource: "recorded", catalogCost: { input: 2, output: 0, cacheRead: 0, cacheWrite: 0, total: 2, }, }, }); expect(entry!.text.length).toBeLessThan(150_000); }); it("retains original image count and previews after a long text exhausts JSON preview limits", async () => { const manager = SessionManager.inMemory(); const data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aMioAAAAASUVORK5CYII="; manager.appendMessage({ role: "user", timestamp: 1, content: [ { type: "text", text: "x".repeat(150_000) }, { type: "image", mimeType: "image/png", data }, ], }); const result = await buildInspectorData( { cwd: "/", sessionManager: manager }, [], ); const entry = result.entries[0]!; expect(entry.metrics).toMatchObject({ imageCount: 1, textBytes: 150_000, imageBytes: Buffer.from(data, "base64").length, }); expect(entry.images).toHaveLength(1); expect(entry.images[0]).toMatchObject({ index: 1, mimeType: "image/png", width: 1, height: 1, }); expect(entry.previewTruncated).toBe(true); expect(result.warnings).toEqual([]); expect(entry.raw).not.toContain(data); }); it("pages all entries without omitted-history caps", async () => { const manager = SessionManager.inMemory(); for (let i = 0; i < 10_001; i++) manager.appendCustomEntry("test", i === 10_000 ? "x".repeat(140_000) : i); const data = await buildInspectorData( { cwd: "/", sessionManager: manager }, [], ); expect(data.entries).toHaveLength(50); expect(data.page.total).toBe(10_001); expect( Buffer.byteLength(data.entries.at(-1)?.raw ?? ""), ).toBeLessThanOrEqual(128 * 1024); expect(data.warnings).toEqual([]); }); it("stops visiting wide payloads and sanitizes oversized readable content", async () => { const manager = SessionManager.inMemory(); let reads = 0; const wide: Record = {}; for (let i = 0; i < 10_000; i++) Object.defineProperty(wide, `key${i}`, { enumerable: true, get() { reads++; return i; }, }); manager.appendCustomEntry("wide", wide); const contentId = manager.appendMessage({ role: "user", content: [ { type: "image", data: "private-image-data", mimeType: "image/png" }, { type: "text", text: "large ".repeat(30_000) }, ], timestamp: 1, }); reads = 0; const data = await buildInspectorData( { cwd: "/", sessionManager: manager }, [], ); expect(reads).toBeLessThan(4_000); expect(reads).toBe(0); expect(data.entries.every((entry) => entry.previewTruncated)).toBe(true); expect(data.warnings).toEqual([]); for (const entry of data.entries) { expect(Buffer.byteLength(entry.raw)).toBeLessThanOrEqual(128 * 1024); expect(Buffer.byteLength(entry.text)).toBeLessThanOrEqual(128 * 1024); expect(`${entry.raw}\n${entry.text}`).not.toContain("private-image-data"); } expect( data.entries.find((entry) => entry.id === contentId)?.images, ).toEqual([ { index: 0, mimeType: "image/png", bytes: null, width: null, height: null, }, ]); }); it("collects tool metadata only from bounded sanitized content", async () => { const manager = SessionManager.inMemory(); let tailReads = 0; const content = Array.from({ length: 10_000 }, (_, i) => ({ type: "toolCall" as const, id: String(i), name: `tool-${i}`, arguments: {}, })); Object.defineProperty(content, 9_000, { get() { tailReads++; return { type: "toolCall", id: "tail", name: "not-visited", arguments: {}, }; }, }); const usage = { input: 1, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 1, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }, }; const assistantId = manager.appendMessage({ role: "assistant", content, api: "openai", provider: "test", model: "test", stopReason: "toolUse", usage, timestamp: 1, }); const toolId = manager.appendMessage({ role: "toolResult", toolCallId: "large", toolName: "name".repeat(50_000), content: [], isError: false, timestamp: 2, }); tailReads = 0; const data = await buildInspectorData( { cwd: "/", sessionManager: manager }, [], ); expect(tailReads).toBe(0); expect( data.entries.find((entry) => entry.id === assistantId)?.toolNames.length, ).toBeLessThan(2_000); expect( data.entries.find((entry) => entry.id === toolId)?.toolNames[0]?.length, ).toBeLessThan(300); expect( data.entries.find((entry) => entry.id === assistantId)?.usage?.input, ).toBe(1); expect(data.entries.every((entry) => entry.previewTruncated)).toBe(true); expect(data.warnings).toEqual([]); }); it("preserves provider signatures and unrelated signature-named tool data", async () => { const manager = SessionManager.inMemory(); manager.appendMessage({ role: "assistant", api: "openai", provider: "test", model: "test", stopReason: "toolUse", timestamp: 1, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }, }, content: [ { type: "text", text: "Visible answer", textSignature: "opaque-text" }, { type: "thinking", thinking: "Visible reasoning", thinkingSignature: "opaque-thinking", }, { type: "toolCall", id: "call", name: "test", thoughtSignature: "opaque-tool", arguments: { signature: "meaningful tool data" }, }, ], }); const [entry] = ( await buildInspectorData({ cwd: "/", sessionManager: manager }, []) ).entries; const content = JSON.parse(entry!.raw).message.content; expect(content[0].textSignature).toBe("opaque-text"); expect(content[1].thinkingSignature).toBe("opaque-thinking"); expect(content[2].thoughtSignature).toBe("opaque-tool"); expect(content[2].arguments.signature).toBe("meaningful tool data"); expect(entry!.text).toContain("Visible answer"); expect(entry!.text).toContain("meaningful tool data"); expect(entry!.text).not.toContain("opaque-"); }); it("serves session images only through the authenticated route and rejects unsafe previews", async () => { const manager = SessionManager.inMemory(); const png = Buffer.from( "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aMioAAAAASUVORK5CYII=", "base64", ); const oversizedDimensions = Buffer.from(png); oversizedDimensions.writeUInt32BE(10_000, 16); oversizedDimensions.writeUInt32BE(10_000, 20); const oversizedSide = Buffer.from(png); oversizedSide.writeUInt32BE(16_385, 16); const id = manager.appendMessage({ role: "user", timestamp: 1, content: [ { type: "image", mimeType: "image/png", data: png.toString("base64") }, { type: "image", mimeType: "image/png", data: oversizedDimensions.toString("base64"), }, { type: "image", mimeType: "image/svg+xml", data: Buffer.from("").toString("base64"), }, { type: "image", mimeType: "image/png", data: "A".repeat(4 * Math.ceil((4 * 1024 * 1024) / 3) + 4), }, { type: "image", mimeType: "image/png", data: "not base64!" }, { type: "image", mimeType: "image/png", data: oversizedSide.toString("base64"), }, ], }); const entry = manager.getEntry(id) as { message: { content: unknown[] } }; entry.message.content[2_001] = { type: "image", mimeType: "image/png", data: png.toString("base64"), }; const inspector = await startInspector( async () => await buildInspectorData({ cwd: "/", sessionManager: manager }, []), (id) => manager.getEntry(id), ); try { expect((await fetch(`${inspector.url}image/${id}/2001`)).status).toBe( 200, ); expect( (await fetch(`${inspector.url}image/${id}/9007199254740992`)).status, ).toBe(404); entry.message.content.length = 6; const imageUrl = `${inspector.url}image/${id}/0`; const response = await fetch(imageUrl); expect(response.status).toBe(200); expect(response.headers.get("content-type")).toBe("image/png"); expect(response.headers.get("cache-control")).toBe("no-store"); expect(response.headers.get("content-security-policy")).toContain( "img-src 'self'", ); expect(Buffer.from(await response.arrayBuffer())).toEqual(png); for (const [index, status] of [ [1, 413], [2, 415], [3, 413], [4, 400], [5, 413], [6, 404], ]) expect( (await fetch(`${inspector.url}image/${id}/${index}`)).status, ).toBe(status); expect( (await fetch(new URL(`/image/${id}/0`, inspector.url))).status, ).toBe(404); expect( (await fetch(imageUrl, { headers: { Origin: "https://evil.invalid" } })) .status, ).toBe(403); const data = await (await fetch(`${inspector.url}data`)).json(); expect(data.entries[0].images).toHaveLength(6); expect(JSON.stringify(data)).not.toContain(png.toString("base64")); } finally { await inspector.close(); } }); it("enforces token, host, origin and method while serving separate JSON", async () => { const manager = SessionManager.inMemory(); const data = await buildInspectorData( { cwd: "/", sessionManager: manager }, [ { id: 1, timestamp: "", entryId: null, prompt: "", grouped: "", }, ], ); const inspector = await startInspector(() => data); try { const url = new URL(inspector.url); for (const asset of ["", "app.js", "app.css"]) { const response = await get(new URL(asset, url).href); expect(response.status).toBe(200); expect(response.body).not.toContain( "", ); } const response = await get(new URL("data", url).href, { headers: { origin: url.origin }, }); expect(response.status).toBe(200); expect(JSON.parse(response.body)).toEqual(data); expect(response.headers["cache-control"]).toBe("no-store"); expect(response.headers["referrer-policy"]).toBe("no-referrer"); expect(response.headers["content-security-policy"]).toContain( "default-src 'none'", ); expect(response.headers["access-control-allow-origin"]).toBeUndefined(); expect((await get(new URL("/data", url).href)).status).toBe(404); expect( ( await get(new URL("data", url).href, { headers: { host: `localhost:${url.port}` }, }) ).status, ).toBe(403); expect( ( await get(new URL("data", url).href, { headers: { origin: "https://evil.invalid" }, }) ).status, ).toBe(403); expect( (await get(new URL("data", url).href, { method: "POST" })).status, ).toBe(405); expect((await get(`${inspector.url}%2e%2e/data`)).status).toBe(404); } finally { await Promise.all([inspector.close(), inspector.close()]); } }); it("starts a successful detail stream and handles a paused client disconnect without eagerly visiting later source fields", async () => { const manager = SessionManager.inMemory(); let reachedTail = false; const tail = new Proxy( { sentinel: "tail" }, { ownKeys(target) { reachedTail = true; return Reflect.ownKeys(target); }, }, ); const source = { content: "x".repeat(32 * 1024 * 1024), tail }; const inspector = await startInspector( async () => await buildInspectorData({ cwd: "/", sessionManager: manager }, []), () => source, ); try { await new Promise((resolve, reject) => { const req = request(`${inspector.url}entry/tracked/json`, (res) => { if (res.statusCode !== 200) { req.destroy(); reject(new Error(`Unexpected detail status ${res.statusCode}`)); return; } res.once("data", (chunk: Buffer) => { if (!chunk.toString().startsWith('{"type":"text","text":')) { req.destroy(); reject(new Error("Detail traversal did not begin")); return; } res.pause(); setTimeout(() => req.destroy(), 80); }); }); req.on("error", (error) => { if ((error as NodeJS.ErrnoException).code !== "ECONNRESET") reject(error); }); req.once("close", resolve); req.end(); }); expect((await fetch(`${inspector.url}data`)).status).toBe(200); await inspector.close(); expect(reachedTail).toBe(false); } finally { await inspector.close(); } }); it("rejects oversized data and hides callback exceptions", async () => { const manager = SessionManager.inMemory(); const data = await buildInspectorData( { cwd: "/", sessionManager: manager }, [], ); let fail = false; const inspector = await startInspector(() => { if (fail) throw new Error("secret error"); return { ...data, name: "x".repeat(32 * 1024 * 1024) }; }); try { expect((await get(`${inspector.url}data`)).status).toBe(413); fail = true; const response = await get(`${inspector.url}data`); expect(response.status).toBe(500); expect(response.body).not.toContain("secret"); } finally { await inspector.close(); } }); });