Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/autopsy/__tests__/inspector.test.ts

Raw
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<string, string> } = {},
) {
	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: "<script>hostile</script>",
				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<string, unknown> = {};
		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("<svg onload='alert(1)'/>").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: "</script><script>alert(1)</script>",
					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(
					"</script><script>alert(1)</script>",
				);
			}
			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<void>((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();
		}
	});
});