repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/autopsy/__tests__/inspector.test.ts
Rawimport { 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();
}
});
});