repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/autopsy/__tests__/browser.test.ts
Rawimport { cp, mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { fileURLToPath } from "node:url";
import { initTheme } from "@earendil-works/pi-coding-agent";
import { expect as browserExpect, chromium } from "@playwright/test";
import { expect, it } from "vitest";
import {
createPiSession,
type PiSession,
} from "../../../test/fixture/create-pi-session.ts";
it.runIf(process.env["PI_AUTOPSY_BROWSER_TESTS"] === "1")(
"renders a relocated package's real Pi capture, filters, usage, refresh and failure states",
async () => {
const root = await mkdtemp(join(tmpdir(), "pi-autopsy-browser-"));
const keepScreenshots = process.env["PI_AUTOPSY_KEEP_SCREENSHOTS"] === "1";
const browser = await chromium.launch();
let pi: PiSession | undefined;
try {
const packageDir = join(root, "package");
await cp(
fileURLToPath(new URL("../../../dist/autopsy", import.meta.url)),
packageDir,
{ recursive: true },
);
const page = await browser.newPage({
viewport: { width: 1100, height: 900 },
colorScheme: "dark",
});
const imageData = await page.evaluate(() => {
const canvas = document.createElement("canvas");
canvas.width = 1000;
canvas.height = 600;
const ctx = canvas.getContext("2d")!;
ctx.fillStyle = "#1556a0";
ctx.fillRect(0, 0, 1000, 600);
ctx.fillStyle = "#f8c080";
ctx.fillRect(50, 50, 900, 500);
ctx.fillStyle = "#20252c";
ctx.font = "48px sans-serif";
ctx.fillText("Local session image", 100, 310);
return canvas.toDataURL("image/png").split(",")[1]!;
});
const extraImages = await page.evaluate(() => {
const canvas = document.createElement("canvas");
canvas.width = 40;
canvas.height = 30;
canvas.getContext("2d")!.fillRect(0, 0, 40, 30);
return {
jpeg: canvas.toDataURL("image/jpeg").split(",")[1]!,
webp: canvas.toDataURL("image/webp").split(",")[1]!,
};
});
const expected =
" Captured identity\n\n<rules>\nStay literal: <script>window.injection = true</script>\n</rules>\n ";
pi = await createPiSession({
extensionPaths: [join(packageDir, "index.ts")],
extensionFactories: [
(api) => {
api.on("before_agent_start", () => ({ systemPrompt: expected }));
},
],
env: { PATH: "/no-browser-openers", TERMUX_VERSION: "fixture" },
});
const manager = pi.session.sessionManager;
const first = manager.appendMessage({
role: "user",
content: "old branch needle",
timestamp: 1,
});
manager.appendCustomEntry("other-branch", { value: "off-branch-only" });
manager.branch(first);
manager.appendUsage("test", "faux", "faux-model", {
input: 17,
output: 5,
cacheRead: 3,
cacheWrite: 0,
totalTokens: 25,
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0.25 },
});
await pi.session.prompt(
"browser journey <img src=x onerror='window.injection=true'>",
);
const oversizedImage = Buffer.from(imageData, "base64");
oversizedImage.writeUInt32BE(10_000, 16);
oversizedImage.writeUInt32BE(10_000, 20);
manager.appendMessage({
role: "user",
timestamp: Date.now(),
content: [
{ type: "text", text: "image journey" },
{ type: "image", mimeType: "image/png", data: imageData },
{
type: "image",
mimeType: "image/png",
data: oversizedImage.toString("base64"),
},
{ type: "image", mimeType: "image/jpeg", data: extraImages.jpeg },
{ type: "image", mimeType: "image/webp", data: extraImages.webp },
{
type: "image",
mimeType: "image/gif",
data: "R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7",
},
],
});
const assistantEntry = manager
.getEntries()
.findLast(
(entry) =>
entry.type === "message" && entry.message.role === "assistant",
);
if (
assistantEntry?.type !== "message" ||
assistantEntry.message.role !== "assistant"
)
throw new Error("missing scripted assistant");
const signature =
"opaque signature <script>window.injection = true</script>";
manager.appendMessage({
...assistantEntry.message,
timestamp: Date.now(),
content: [
{ type: "text", text: "signature journey", textSignature: signature },
],
});
const quotedKey = 'escaped"key\\';
const jsonEntryId = manager.appendCustomEntry("json-highlighting", {
[quotedKey]:
'quote: " slash: \\ <img src=x onerror="window.injection=true">',
flags: [true, false, null],
number: -1.25e-8,
});
initTheme(undefined, false);
const ctx = pi.session.extensionRunner.createCommandContext();
let url = "";
ctx.ui.notify = (message) => {
url = message.match(/http:\/\/127\.0\.0\.1:\d+\/\w+\//u)?.[0] ?? "";
};
await pi.extensions[0]!.commands.get("autopsy")!.handler("", ctx);
expect(url).toMatch(/^http:/u);
const errors: string[] = [];
const imageRequests: string[] = [];
page.on("request", (request) => {
if (request.url().includes("/image/"))
imageRequests.push(request.url());
});
page.on("pageerror", (error) => errors.push(error.message));
await page.goto(url);
await browserExpect(page).toHaveTitle("Session · Autopsy");
const initialStatus = {
text: await page.locator("#status").textContent(),
hidden: await page.locator("#status").isHidden(),
};
await page.getByRole("button", { name: "Insights", exact: true }).click();
await browserExpect(page.locator("#usage-chart")).toContainText("25");
await browserExpect(
page.locator("#usage-chart .bar").first(),
).toHaveJSProperty(
"offsetWidth",
await page
.locator("#usage-chart .bar")
.first()
.evaluate((node) => node.parentElement!.clientWidth),
);
await page
.getByRole("dialog", { name: "Insights", exact: true })
.getByRole("button", { name: "Close", exact: true })
.click();
await page.locator("#search").fill("off-branch-only");
await browserExpect(page.locator("#entry-count")).toHaveText("0 entries");
await browserExpect(page.locator("#status")).toBeHidden();
await page.getByRole("button", { name: "Filters", exact: true }).click();
await page.locator("#branch").selectOption("all");
await page
.getByRole("dialog", { name: "Filters", exact: true })
.getByRole("button", { name: "Close", exact: true })
.click();
await browserExpect(page.locator("#entry-count")).toHaveText("1 entry");
await page.locator("#search").fill("browser journey");
await page.getByRole("button", { name: "Filters", exact: true }).click();
await page.locator("#role").selectOption("user");
await page
.getByRole("dialog", { name: "Filters", exact: true })
.getByRole("button", { name: "Close", exact: true })
.click();
await browserExpect(page.locator("#entry-count")).toHaveText("1 entry");
await page.locator(".entry > summary").click();
await browserExpect(
page.locator(".entry-body pre").first(),
).toContainText("<img");
expect(
await page.locator(".entry-body img, .entry-body script").count(),
).toBe(0);
expect(await page.evaluate(() => "injection" in window)).toBe(false);
expect(imageRequests).toEqual([]);
await page.locator("#search").fill("signature journey");
await page.getByRole("button", { name: "Filters", exact: true }).click();
await page.locator("#role").selectOption("assistant");
await page
.getByRole("dialog", { name: "Filters", exact: true })
.getByRole("button", { name: "Close", exact: true })
.click();
await page.locator(".entry > summary").click();
await browserExpect(page.locator(".entry-json")).not.toHaveAttribute(
"open",
);
expect(await page.locator(".entry-body").textContent()).not.toContain(
signature,
);
await page.locator(".entry-json > summary").click();
await browserExpect(page.locator(".entry-json pre")).toContainText(
signature,
);
expect(await page.evaluate(() => "injection" in window)).toBe(false);
await page.locator(".entry-json > summary").click();
await browserExpect(page.locator(".entry-json pre")).toBeHidden();
await page.getByRole("button", { name: "Filters", exact: true }).click();
await page.locator("#role").selectOption("");
await page
.getByRole("dialog", { name: "Filters", exact: true })
.getByRole("button", { name: "Close", exact: true })
.click();
await page.locator("#search").fill("json-highlighting");
await browserExpect(
page.locator(`.entry[data-entry-id="${jsonEntryId}"]`),
).toBeVisible();
await page
.locator(`.entry[data-entry-id="${jsonEntryId}"] > summary`)
.click();
await page.locator(".entry-json > summary").click();
const json = page.locator(".entry-json .json-code");
await browserExpect(
page.locator(".entry-json > .entry-load-status"),
).toHaveText("");
const inspectorData = await (
await fetch(`${url}data?branch=all&q=json-highlighting`)
).json();
expect(
inspectorData.entries.map((entry: { id: string }) => entry.id),
).toContain(jsonEntryId);
expect(await json.textContent()).toBe(
JSON.stringify(manager.getEntry(jsonEntryId), null, 2),
);
expect(await json.locator(".json-key").allTextContents()).toContain(
JSON.stringify(quotedKey),
);
await browserExpect(json.locator(".json-number")).toHaveText("-1.25e-8");
await browserExpect(json.locator(".json-literal")).toHaveText([
"true",
"false",
"null",
]);
expect(await json.locator(".json-string").count()).toBeGreaterThan(0);
expect(await json.locator("img, script").count()).toBe(0);
expect(await page.evaluate(() => "injection" in window)).toBe(false);
await page
.locator(".entry")
.screenshot({ path: join(root, "json-dark.png") });
await page.emulateMedia({ colorScheme: "light" });
await page.setViewportSize({ width: 390, height: 844 });
expect(
await page.evaluate(
() => document.documentElement.scrollWidth <= window.innerWidth,
),
).toBe(true);
await page
.locator(".entry")
.screenshot({ path: join(root, "json-light-mobile.png") });
await page.emulateMedia({ colorScheme: "dark" });
await page.setViewportSize({ width: 1100, height: 900 });
await page.getByRole("button", { name: "Filters", exact: true }).click();
await page.locator("#role").selectOption("user");
await page
.getByRole("dialog", { name: "Filters", exact: true })
.getByRole("button", { name: "Close", exact: true })
.click();
await page.locator("#search").fill("image journey");
await page.locator(".entry > summary").click();
expect(imageRequests).toEqual([]);
const imageViewer = page.locator(".image-viewer").first();
await browserExpect(imageViewer.locator("summary")).toHaveText(
/^Image 1 · image\/png · [\d,.]+ B · 1000 × 600 px$/u,
);
await browserExpect(
page.locator(".image-viewer").nth(1).locator("summary"),
).toHaveText(/^Image 2 · image\/png · [\d,.]+ B · 10000 × 10000 px$/u);
await imageViewer.locator("summary").click();
await browserExpect(imageViewer.locator("img")).toHaveJSProperty(
"naturalWidth",
1000,
);
await browserExpect(imageViewer.locator("img")).toHaveJSProperty(
"naturalHeight",
600,
);
expect(imageRequests).toHaveLength(1);
expect(imageRequests[0]).toMatch(/\/1$/u);
expect(
(await imageViewer.locator("img").boundingBox())!.width,
).toBeLessThan(1000);
await imageViewer
.getByRole("button", { name: "Show original size" })
.click();
await browserExpect(imageViewer.locator(".image-viewport")).toHaveClass(
/image-original/u,
);
expect((await imageViewer.locator("img").boundingBox())!.width).toBe(
1000,
);
await imageViewer
.getByRole("button", { name: "Show preview size" })
.click();
for (const [index, width] of [
[2, 40],
[3, 40],
[4, 1],
] as const) {
const preview = page.locator(".image-viewer").nth(index);
await preview.locator("summary").click();
await browserExpect(preview.locator("img")).toHaveJSProperty(
"naturalWidth",
width,
);
await preview.locator("summary").click();
await browserExpect(preview.locator("img")).toHaveCount(0);
}
await page.screenshot({
path: join(root, "image-dark.png"),
fullPage: true,
});
await page.emulateMedia({ colorScheme: "light" });
await page.setViewportSize({ width: 390, height: 844 });
expect(
await page.evaluate(
() => document.documentElement.scrollWidth <= window.innerWidth,
),
).toBe(true);
await page.screenshot({
path: join(root, "image-light-mobile.png"),
fullPage: true,
});
await page.emulateMedia({ colorScheme: "dark" });
await page.setViewportSize({ width: 1100, height: 900 });
await imageViewer.locator("summary").click();
await browserExpect(imageViewer.locator("img")).toHaveCount(0);
const rejectedImage = page.locator(".image-viewer").nth(1);
await rejectedImage.locator("summary").click();
await browserExpect(rejectedImage.locator(".image-status")).toContainText(
"Image unavailable",
);
expect(imageRequests.at(-1)).toMatch(/\/2$/u);
await page.locator(".entry > summary").click();
await browserExpect(rejectedImage.locator("img")).toHaveCount(0);
await page.getByRole("button", { name: "Session", exact: true }).click();
await browserExpect(page.locator("#metadata")).toContainText(
"Snapshot generated",
);
await page.locator("#captures > summary").click();
await browserExpect(page.locator("#prompt-raw")).toHaveText(expected);
expect(await page.locator("#prompt-raw").textContent()).toBe(expected);
await browserExpect(page.locator("#prompt-grouped")).toContainText(
"[RULES]",
);
await page.screenshot({
path: join(root, "prompt-dark.png"),
fullPage: true,
});
await page
.getByRole("dialog", { name: "Session", exact: true })
.getByRole("button", { name: "Close", exact: true })
.click();
await page.locator("#search").fill("");
await page.getByRole("button", { name: "Filters", exact: true }).click();
await page.locator("#role").selectOption("");
await page
.getByRole("dialog", { name: "Filters", exact: true })
.getByRole("button", { name: "Close", exact: true })
.click();
manager.appendCustomEntry("refresh-test", { text: "fresh entry" });
await page.locator("#refresh").click();
await page.locator("#search").fill("fresh entry");
await browserExpect(page.locator("#entry-count")).toHaveText("1 entry");
const resetScope = page.waitForResponse((response) => {
const request = new URL(response.url());
return (
request.pathname.endsWith("/data") && !request.searchParams.has("q")
);
});
await page.locator("#search").fill("");
await resetScope;
await browserExpect(page.locator("#entry-count")).not.toHaveText(
"1 entry",
);
await page.emulateMedia({ colorScheme: "light" });
await page.setViewportSize({ width: 390, height: 844 });
expect(
await page.evaluate(
() => document.documentElement.scrollWidth <= window.innerWidth,
),
).toBe(true);
await page.screenshot({
path: join(root, "session-light-mobile.png"),
fullPage: true,
});
const visibleEntries = await page.locator("#entries").textContent();
expect(await page.locator(".entry").count()).toBeGreaterThan(0);
await pi.dispose();
pi = undefined;
await page.locator("#refresh").click();
await browserExpect(page.locator("#status")).toContainText(
"History load failed:",
);
await browserExpect(page.locator("#entries")).toHaveText(visibleEntries!);
expect(initialStatus).toEqual({ text: "", hidden: true });
expect(errors).toEqual([]);
} finally {
await browser.close();
await pi?.dispose();
if (keepScreenshots) {
await rm(join(root, "package"), { recursive: true, force: true });
console.log(`Browser screenshots: ${root}`);
} else await rm(root, { recursive: true, force: true });
}
},
30_000,
);
it.runIf(process.env["PI_AUTOPSY_BROWSER_TESTS"] === "1")(
"shows source-aware dashboard metrics, shared filters, time graphs and transcript drill-down",
async () => {
const root = await mkdtemp(join(tmpdir(), "pi-autopsy-dashboard-"));
const keepScreenshots = process.env["PI_AUTOPSY_KEEP_SCREENSHOTS"] === "1";
const browser = await chromium.launch();
let pi: PiSession | undefined;
try {
const packageDir = join(root, "package");
await cp(
fileURLToPath(new URL("../../../dist/autopsy", import.meta.url)),
packageDir,
{ recursive: true },
);
const provider = "autopsy-metrics-test";
const model = "priced";
pi = await createPiSession({
extensionPaths: [join(packageDir, "index.ts")],
extensionFactories: [
(api) => {
api.registerProvider(provider, {
api: "openai",
apiKey: "test-key",
baseUrl: "https://unused.invalid",
models: [
{
id: model,
name: "Priced test model",
reasoning: false,
input: ["text"],
contextWindow: 10000,
maxTokens: 512,
cost: { input: 2, output: 4, cacheRead: 1, cacheWrite: 3 },
},
],
});
},
],
env: { PATH: "/no-browser-openers", TERMUX_VERSION: "fixture" },
});
await pi.session.prompt("real Pi dashboard setup");
const manager = pi.session.sessionManager;
const completeUsage = {
input: 1_000_000,
output: 500_000,
cacheRead: 100_000,
cacheWrite: 0,
totalTokens: 1_600_000,
cost: {
input: 3,
output: 3,
cacheRead: 1,
cacheWrite: 0,
total: 7,
totalFromProvider: true,
},
};
const missingUsage = {
input: Number.NaN,
output: 0,
cacheRead: 0,
cacheWrite: 0,
totalTokens: 0,
cost: {
input: 0,
output: 0,
cacheRead: 0,
cacheWrite: 0,
total: Number.NaN,
},
};
const start = Date.parse("2026-01-01T00:00:10.000Z");
const firstId = manager.appendMessage({
role: "assistant",
api: "openai",
provider,
model,
timestamp: start,
durationMs: 2500,
content: [{ type: "text", text: "dashboard priced response" }],
usage: completeUsage,
stopReason: "stop",
});
const secondId = manager.appendMessage({
role: "assistant",
api: "openai",
provider,
model,
timestamp: start + 10000,
durationMs: 0,
content: [{ type: "text", text: "dashboard missing usage" }],
usage: missingUsage,
stopReason: "stop",
});
const first = manager.getEntry(firstId)!;
const second = manager.getEntry(secondId)!;
// Deterministic recorded-entry timestamps, distinct from request starts.
first.timestamp = "2026-01-01T00:00:12.500Z";
second.timestamp = "2026-01-01T00:00:20.000Z";
const toolId = manager.appendMessage({
role: "toolResult",
toolCallId: "dashboard-tool",
toolName: "measure",
timestamp: start + 3000,
durationMs: 1500,
content: [],
isError: false,
});
manager.getEntry(toolId)!.timestamp = "2026-01-01T00:00:13.000Z";
initTheme(undefined, false);
const ctx = pi.session.extensionRunner.createCommandContext();
let url = "";
ctx.ui.notify = (message) => {
url = message.match(/http:\/\/127\.0\.0\.1:\d+\/\w+\//u)?.[0] ?? "";
};
await pi.extensions[0]!.commands.get("autopsy")!.handler("", ctx);
expect(url).toMatch(/^http:/u);
const page = await browser.newPage({
viewport: { width: 1100, height: 900 },
colorScheme: "dark",
locale: "en-US",
timezoneId: "UTC",
});
const errors: string[] = [];
page.on("pageerror", (error) => errors.push(error.message));
await page.goto(url);
await browserExpect(
page.locator("#entries > .entry").first(),
).toBeVisible();
await page.locator("#filters-button").click();
await browserExpect(page.locator("#filters-panel")).toBeVisible();
await page.locator("#provider").selectOption({ label: provider });
await page.locator("#model").selectOption({ label: model });
await page.locator("#filters-panel [data-close]").click();
await browserExpect(page.locator("#entry-count")).toContainText(
"2 entries",
);
await page.locator("#insights-button").click();
await browserExpect(page.locator("#insights-panel")).toBeVisible();
const card = (metric: string) =>
page.locator(`[data-metric="${metric}"]`);
await browserExpect(
card("stored-cost").locator(".card-value"),
).toHaveText("$7");
await browserExpect(
card("catalog-cost").locator(".card-value"),
).toHaveText("$4.1");
await browserExpect(
card("stored-cost").locator(".card-coverage"),
).toHaveText("1/2 entries known");
await browserExpect(
card("catalog-cost").locator(".card-coverage"),
).toHaveText("1/2 entries known");
await browserExpect(card("tokens").locator(".card-value")).toHaveText(
"1,600,000",
);
await browserExpect(card("duration").locator(".card-value")).toHaveText(
"2.5 s",
);
await browserExpect(card("size").locator(".card-value")).toHaveText(
"48 B",
);
await browserExpect(page.locator("#dashboard-timing")).toContainText(
"7.5 s",
);
await browserExpect(
page.locator("#dashboard-timelines .timeline-point"),
).toHaveCount(2);
await browserExpect(
page.locator(`#dashboard-timelines [data-entry-id="${secondId}"]`),
).toHaveCount(0);
await page.locator("#timeline-view").selectOption("tokens");
await browserExpect(
page.locator(
`.timeline-point[data-entry-id="${secondId}"][aria-label^="Input:"]`,
),
).toHaveCount(0);
await browserExpect(
page.locator(
`.timeline-point[data-entry-id="${secondId}"][aria-label^="Output:"]`,
),
).toHaveAttribute("aria-label", /Output: 0/u);
await page.locator("#timeline-view").selectOption("duration");
await browserExpect(
page.locator(`.timeline-point[data-entry-id="${secondId}"]`),
).toHaveAttribute("aria-label", /Model response: 0 s/u);
await page.locator("#timeline-view").selectOption("size");
await browserExpect(
page.locator("#dashboard-timelines svg"),
).toHaveAttribute("aria-label", /content size/u);
await page.locator("#timeline-view").selectOption("cumulative");
await browserExpect(
page.locator("#dashboard-timelines h4"),
).toContainText("Cumulative known cost");
await page.locator("#insights-panel [data-close]").click();
await page.locator("#filters-button").click();
await page.locator("#from").fill("2026-01-01T00:00:12.5");
await page.locator("#from").dispatchEvent("change");
await page.locator("#to").fill("2026-01-01T00:00:12.5");
await page.locator("#to").dispatchEvent("change");
await browserExpect(page.locator("#entry-count")).toContainText(
"1 entry",
);
await page.locator("#filters-panel [data-close]").click();
await page.locator("#insights-button").click();
await browserExpect(
card("stored-cost").locator(".card-coverage"),
).toHaveText("1/1 entries known");
await page.locator("#insights-panel [data-close]").click();
await page.locator("#filters-button").click();
await page.locator("#from").fill("2026-01-01T00:00:20");
await page.locator("#from").dispatchEvent("change");
await browserExpect(page.locator("#to")).toHaveJSProperty(
"validationMessage",
"To must be on or after From.",
);
await browserExpect(page.locator("#entry-count")).toContainText(
"1 entry",
);
await page.locator("#filters-panel [data-close]").click();
await page.locator("#insights-button").click();
await browserExpect(
card("stored-cost").locator(".card-value"),
).toHaveText("$7");
await page.locator("#insights-panel [data-close]").click();
await page.locator("#filters-button").click();
await page.locator("#reset-filters").click();
await page.locator("#role").selectOption("toolResult");
await page.locator("#filters-panel [data-close]").click();
await page.locator("#insights-button").click();
await page.locator("#timeline-view").selectOption("duration");
await browserExpect(
page.locator(`.timeline-point[data-entry-id="${toolId}"]`),
).toHaveAttribute("aria-label", /Tool execution: 1.5 s/u);
await page.locator("#insights-panel [data-close]").click();
await page.locator("#filters-button").click();
await page.locator("#reset-filters").click();
await page.locator("#filters-panel [data-close]").click();
const zeroUsage = {
input: 0,
output: 0,
cacheRead: 0,
cacheWrite: 0,
totalTokens: 0,
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
};
for (let i = 0; i < 54; i++) {
const entry = manager.appendUsage(
"dashboard-pagination",
provider,
model,
zeroUsage,
);
entry.timestamp = new Date(
Date.parse("2025-12-31T23:59:00.000Z") + i * 1000,
).toISOString();
}
await page.locator("#refresh").click();
await page.locator("#filters-button").click();
await page.locator("#provider").selectOption({ label: provider });
await page.locator("#model").selectOption({ label: model });
await page.locator("#order").selectOption("newest");
await page.locator("#filters-panel [data-close]").click();
await page.locator("#insights-button").click();
await page.locator("#timeline-view").selectOption("cost");
await browserExpect(page.locator("#entry-count")).toContainText(
"56 entries",
);
const point = page
.locator(`.timeline-point[data-entry-id="${firstId}"]`)
.first();
await browserExpect(
page.locator(`.entry[data-entry-id="${firstId}"]`),
).toHaveCount(0);
const around = page.waitForRequest(
(request) =>
new URL(request.url()).searchParams.get("around") === firstId,
);
await point.focus();
await point.press("Enter");
await around;
await browserExpect(page.locator("#insights-panel")).not.toBeVisible();
await browserExpect(
page.locator(`.entry[data-entry-id="${firstId}"]`),
).toHaveAttribute("open");
await browserExpect(
page.locator(`.entry[data-entry-id="${firstId}"] > summary`),
).toBeFocused();
await page.locator("#insights-button").click();
await page
.locator("#insights-panel")
.screenshot({ path: join(root, "dashboard-dark.png") });
await page.locator("#dashboard-totals > details > summary").click();
await page
.locator("#dashboard-totals > details")
.screenshot({ path: join(root, "dashboard-details-dark.png") });
await page.locator("#dashboard-totals > details > summary").click();
await page.emulateMedia({ colorScheme: "light" });
await page.setViewportSize({ width: 390, height: 844 });
expect(
await page.evaluate(
() => document.documentElement.scrollWidth <= window.innerWidth,
),
).toBe(true);
await page
.locator("#insights-panel")
.screenshot({ path: join(root, "dashboard-light-mobile.png") });
await page.locator("#dashboard-totals > details > summary").click();
expect(
await page.evaluate(
() => document.documentElement.scrollWidth <= window.innerWidth,
),
).toBe(true);
await page
.locator("#dashboard-totals > details")
.screenshot({ path: join(root, "dashboard-details-light-mobile.png") });
expect(errors).toEqual([]);
} finally {
await browser.close();
await pi?.dispose();
if (keepScreenshots) {
await rm(join(root, "package"), { recursive: true, force: true });
console.log(`Dashboard screenshots: ${root}`);
} else await rm(root, { recursive: true, force: true });
}
},
30_000,
);
it.runIf(process.env["PI_AUTOPSY_BROWSER_TESTS"] === "1")(
"streams complete content on click, preserves unchanged rows and recovers from interrupted details",
async () => {
const root = await mkdtemp(join(tmpdir(), "pi-autopsy-previews-"));
const keepScreenshots = process.env["PI_AUTOPSY_KEEP_SCREENSHOTS"] === "1";
const browser = await chromium.launch();
let pi: PiSession | undefined;
try {
const packageDir = join(root, "package");
await cp(
fileURLToPath(new URL("../../../dist/autopsy", import.meta.url)),
packageDir,
{ recursive: true },
);
pi = await createPiSession({
extensionPaths: [join(packageDir, "index.ts")],
env: { PATH: "/no-browser-openers", TERMUX_VERSION: "fixture" },
});
await pi.session.prompt("preview setup");
const manager = pi.session.sessionManager;
const marker = "preview-stream-fixture";
const sentinel = "COMPLETE-TEXT-SENTINEL";
const body = `${marker}\n${"long line 🦊 [truncated] <img src=x>\n".repeat(12_000)}${sentinel}`;
const signature = `${"opaque-signature".repeat(20_000)}SIGNATURE-END`;
const usage = {
input: 0,
output: 0,
cacheRead: 0,
cacheWrite: 0,
totalTokens: 0,
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
};
const id = manager.appendMessage({
role: "assistant",
api: "openai",
provider: "faux",
model: "faux-model",
timestamp: Date.now(),
content: [{ type: "text", text: body, textSignature: signature }],
usage,
stopReason: "stop",
});
manager.appendMessage({
role: "user",
timestamp: Date.now(),
content: "literal-marker-fixture [truncated] is original text",
});
const cancelMarker = "preview-cancel-fixture";
const cancelSentinel = "CANCEL-REOPEN-SENTINEL";
const cancelBody = `${cancelMarker}\n${"cancel segment\n".repeat(100_000)}${cancelSentinel}`;
const disposedId = manager.appendMessage({
role: "user",
timestamp: Date.now(),
content: "preview-disposed-fixture",
});
const cancelId = manager.appendMessage({
role: "user",
timestamp: Date.now(),
content: cancelBody,
});
initTheme(undefined, false);
const ctx = pi.session.extensionRunner.createCommandContext();
let url = "";
ctx.ui.notify = (message) => {
url = message.match(/http:\/\/127\.0\.0\.1:\d+\/\w+\//u)?.[0] ?? "";
};
await pi.extensions[0]!.commands.get("autopsy")!.handler("", ctx);
expect(url).toMatch(/^http:/u);
const page = await browser.newPage({
viewport: { width: 1100, height: 900 },
colorScheme: "dark",
});
const requests: string[] = [];
const errors: string[] = [];
page.on("request", (request) => {
if (request.url().includes("/entry/")) requests.push(request.url());
});
page.on("pageerror", (error) => errors.push(error.message));
await page.goto(url);
await browserExpect(
page.locator("#entries > .entry").first(),
).toBeVisible();
await browserExpect(page.locator("#history")).toHaveAttribute(
"aria-busy",
"false",
);
const initialStatus = {
text: await page.locator("#status").textContent(),
hidden: await page.locator("#status").isHidden(),
};
expect(requests).toEqual([]);
await page.locator("#filters-button").click();
await browserExpect(page.locator("#filters-panel")).toBeVisible();
await browserExpect(page.locator("#branch")).toHaveValue("current");
await page.locator("#filters-panel [data-close]").click();
await page.locator("#session-button").click();
await browserExpect(page.locator("#session-panel")).toBeVisible();
await browserExpect(page.locator("#warnings")).not.toContainText(
"truncated for viewer",
);
await browserExpect(page.locator("#warnings")).not.toContainText(
"Session history",
);
await browserExpect(page.locator(".session-note")).toContainText(
"Session history",
);
await page.locator("#session-panel [data-close]").click();
await page.locator("#search").fill("literal-marker-fixture");
await browserExpect(page.locator(".preview-limited")).toHaveCount(0);
const markerScope = page.waitForResponse((response) => {
const request = new URL(response.url());
return (
request.pathname.endsWith("/data") &&
request.searchParams.get("q") === marker
);
});
await page.locator("#search").fill(marker);
await markerScope;
const row = page.locator(`.entry[data-entry-id="${id}"]`);
await browserExpect(row.locator(".preview-limited")).toHaveCount(0);
expect(
(await row.locator(".entry-preview").textContent())!.length,
).toBeLessThanOrEqual(600);
expect(await row.locator(".entry-preview").textContent()).not.toContain(
sentinel,
);
await row.screenshot({ path: join(root, "preview-dark.png") });
await row.locator(":scope > summary").click();
await browserExpect(row.locator(".entry-full-text pre")).toContainText(
sentinel,
{ timeout: 15000 },
);
await browserExpect(
row.locator(".entry-body > .entry-load-status"),
).toHaveText("");
const text = row.locator(".entry-full-text pre");
expect(
await text.evaluate(
(node, expected) => node.textContent === expected,
body,
),
).toBe(true);
expect(await text.locator("img, script").count()).toBe(0);
expect(
requests.filter((request) => request.endsWith(`/entry/${id}/text`)),
).toHaveLength(1);
expect(
requests.filter((request) => request.endsWith(`/entry/${id}/json`)),
).toHaveLength(0);
const originalRow = await row.elementHandle();
const selected = await text.evaluate((node) => {
const range = document.createRange();
range.setStart(node.firstChild!, 0);
range.setEnd(node.firstChild!, 7);
window.getSelection()!.removeAllRanges();
window.getSelection()!.addRange(range);
return window.getSelection()!.toString();
});
const history = page.locator("#history");
await history.evaluate((node) => {
node.scrollTop = 100;
});
expect(await history.evaluate((node) => node.scrollTop)).toBe(100);
const anchorTop = await text.evaluate(
(node) => node.getBoundingClientRect().top,
);
const refreshed = page.waitForResponse(
(response) =>
new URL(response.url()).pathname === new URL("data", url).pathname,
);
await page
.locator("#refresh")
.evaluate((node: HTMLButtonElement) => node.click());
const dataUrl = (await refreshed).url();
await browserExpect(page.locator("#refresh")).toBeEnabled();
expect(await originalRow!.evaluate((node) => node.isConnected)).toBe(
true,
);
await browserExpect(row).toHaveAttribute("open");
expect(await page.evaluate(() => window.getSelection()!.toString())).toBe(
selected,
);
expect(
await text.evaluate((node) => node.getBoundingClientRect().top),
).toBeCloseTo(anchorTop, 0);
expect(
requests.filter((request) => request.endsWith(`/entry/${id}/text`)),
).toHaveLength(1);
const changed = await (await fetch(dataUrl)).json();
const changedEntry = changed.entries.find(
(entry: { id: string }) => entry.id === id,
);
changedEntry.metrics.durationMs = 1234;
changedEntry.metrics.textBytes = null;
changedEntry.metrics.totalBytes = null;
changedEntry.usage.catalogCost = {
input: 1,
output: 2,
cacheRead: 0,
cacheWrite: 0,
total: 3,
};
await page.route(`${url}data?**`, (route) =>
route.fulfill({
contentType: "application/json",
body: JSON.stringify(changed),
}),
);
const changedResponse = page.waitForResponse(
(response) => response.url() === dataUrl,
);
await page
.locator("#refresh")
.evaluate((node: HTMLButtonElement) => node.click());
await changedResponse;
await browserExpect(page.locator("#refresh")).toBeEnabled();
await page.unroute(`${url}data?**`);
expect(await originalRow!.evaluate((node) => node.isConnected)).toBe(
true,
);
expect(await page.evaluate(() => window.getSelection()!.toString())).toBe(
selected,
);
expect(
await text.evaluate((node) => node.getBoundingClientRect().top),
).toBeCloseTo(anchorTop, 0);
await browserExpect(row.locator(".entry-metadata")).not.toHaveAttribute(
"open",
);
await row.locator(".entry-metadata > summary").click();
await browserExpect(row.locator(".entry-meta")).toContainText("1.234 s");
await row
.getByText("Usage and size measurements", { exact: true })
.click();
await browserExpect(
row.getByRole("row", {
name: "Current catalog estimate (USD) $3",
exact: true,
}),
).toBeVisible();
await browserExpect(
row.getByRole("row", { name: "Text bytes Unknown", exact: true }),
).toBeVisible();
await row
.getByText("Usage and size measurements", { exact: true })
.click();
await row.locator(".entry-metadata > summary").click();
expect(
requests.filter((request) => request.endsWith(`/entry/${id}/text`)),
).toHaveLength(1);
await page.route(`**/entry/${id}/json`, (route) =>
route.fulfill({
status: 200,
contentType: "application/x-ndjson",
body: `${JSON.stringify({ type: "text", text: '{"partial":true' })}\n`,
}),
);
await row.locator(".entry-json > summary").click();
await browserExpect(
row.locator(".entry-json > .entry-load-status"),
).toContainText("Load failed");
await browserExpect(row.locator(".entry-preview")).toContainText(marker);
await page.unroute(`**/entry/${id}/json`);
await row
.getByRole("button", { name: "Retry JSON", exact: true })
.click();
await browserExpect(
row.locator(".entry-json > .entry-load-status"),
).toHaveText("");
const completeJson = JSON.parse(
(await row.locator(".entry-json .json-code").textContent())!,
);
expect(completeJson.message.content[0].text === body).toBe(true);
expect(completeJson.message.content[0].textSignature === signature).toBe(
true,
);
await row.locator(".entry-json > summary").click();
await text.evaluate((node) => {
node.scrollTop = node.scrollHeight;
});
await row.screenshot({ path: join(root, "complete-dark.png") });
await page.locator("#search").fill(cancelMarker);
const cancelRow = page.locator(`.entry[data-entry-id="${cancelId}"]`);
const cdp = await page.context().newCDPSession(page);
await cdp.send("Network.enable");
await cdp.send("Network.emulateNetworkConditions", {
offline: false,
latency: 0,
downloadThroughput: 64 * 1024,
uploadThroughput: -1,
});
const aborted = page.waitForEvent("requestfailed", {
predicate: (request) =>
request.url() === `${url}entry/${cancelId}/text`,
timeout: 5000,
});
await cancelRow.locator(":scope > summary").click();
await browserExpect(
cancelRow.locator(".entry-full-text pre"),
).toContainText(cancelMarker);
await cancelRow.locator(":scope > summary").click();
await aborted;
await cdp.send("Network.emulateNetworkConditions", {
offline: false,
latency: 0,
downloadThroughput: -1,
uploadThroughput: -1,
});
await cancelRow.locator(":scope > summary").click();
await browserExpect(
cancelRow.locator(".entry-body > .entry-load-status"),
).toHaveText("");
expect(
await cancelRow
.locator(".entry-full-text pre")
.evaluate(
(node, expected) => node.textContent === expected,
cancelBody,
),
).toBe(true);
expect(
requests.filter((request) =>
request.endsWith(`/entry/${cancelId}/text`),
),
).toHaveLength(2);
await page.emulateMedia({ colorScheme: "light" });
await page.setViewportSize({ width: 390, height: 844 });
await cancelRow.locator(".entry-full-text pre").evaluate((node) => {
node.scrollTop = node.scrollHeight;
});
expect(
await page.evaluate(
() => document.documentElement.scrollWidth <= window.innerWidth,
),
).toBe(true);
await page.screenshot({
path: join(root, "complete-light-mobile.png"),
});
await cancelRow.locator(":scope > summary").click();
await cancelRow.screenshot({
path: join(root, "preview-light-mobile.png"),
});
await page.locator("#search").fill("preview-disposed-fixture");
const disposedRow = page.locator(`.entry[data-entry-id="${disposedId}"]`);
await browserExpect(disposedRow).toBeVisible();
const disposedRoot = await disposedRow.elementHandle();
await page.locator("#search").fill("no-matching-entry");
await browserExpect(page.locator(".entry")).toHaveCount(0);
await disposedRoot!.evaluate(async (node) => {
const row = node as HTMLDetailsElement;
const raw = row.querySelector<HTMLDetailsElement>(".entry-json")!;
const toggled = Promise.all([
new Promise<void>((resolve) =>
row.addEventListener("toggle", () => resolve(), { once: true }),
),
new Promise<void>((resolve) =>
raw.addEventListener("toggle", () => resolve(), { once: true }),
),
]);
row.open = true;
raw.open = true;
await toggled;
});
await browserExpect(page.locator(".entry")).toHaveCount(0);
expect(
requests.some((request) => request.includes(`/entry/${disposedId}/`)),
).toBe(false);
expect(initialStatus).toEqual({ text: "", hidden: true });
expect(errors).toEqual([]);
} finally {
await browser.close();
await pi?.dispose();
if (keepScreenshots) {
await rm(join(root, "package"), { recursive: true, force: true });
console.log(`Preview screenshots: ${root}`);
} else await rm(root, { recursive: true, force: true });
}
},
45_000,
);
it.runIf(process.env["PI_AUTOPSY_BROWSER_TESTS"] === "1")(
"lazily scrolls relocated real history without losing scope totals or open readers",
async () => {
type InspectorData = import("../src/types.ts").InspectorData;
const root = await mkdtemp(join(tmpdir(), "pi-autopsy-history-"));
const keepScreenshots = process.env["PI_AUTOPSY_KEEP_SCREENSHOTS"] === "1";
const browser = await chromium.launch();
let pi: PiSession | undefined;
let releaseCursor = () => {};
try {
const packageDir = join(root, "package");
await cp(
fileURLToPath(new URL("../../../dist/autopsy", import.meta.url)),
packageDir,
{ recursive: true },
);
pi = await createPiSession({
extensionPaths: [join(packageDir, "index.ts")],
env: { PATH: "/no-browser-openers", TERMUX_VERSION: "fixture" },
});
const manager = pi.session.sessionManager;
manager.appendUsage("test", "faux", "faux-model", {
input: 17,
output: 5,
cacheRead: 3,
cacheWrite: 0,
totalTokens: 25,
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0.25 },
});
const bodies = new Map<string, string>();
for (let index = 0; index < 300; index++) {
const body =
`History ${index}: investigating a real captured session.\n` +
"Substantial recorded content, available completely on demand. ".repeat(
420,
) +
`\nCOMPLETE-HISTORY-TAIL-${index}`;
const id = manager.appendMessage({
role: "user",
timestamp: Date.UTC(2026, 0, 1) + index * 1000,
content: body,
});
bodies.set(id, body);
}
expect(
[...bodies.values()].reduce((sum, body) => sum + body.length, 0),
).toBeGreaterThan(4 * 1024 * 1024);
const newestId = [...bodies.keys()].at(-1)!;
const oldestId = manager.getBranch()[0]!.id;
initTheme(undefined, false);
const ctx = pi.session.extensionRunner.createCommandContext();
let url = "";
ctx.ui.notify = (message) => {
url = message.match(/http:\/\/127\.0\.0\.1:\d+\/\w+\//u)?.[0] ?? "";
};
await pi.extensions[0]!.commands.get("autopsy")!.handler("", ctx);
expect(url).toMatch(/^http:/u);
const page = await browser.newPage({
viewport: { width: 1100, height: 10000 },
colorScheme: "dark",
});
const requests: URL[] = [];
const errors: string[] = [];
const pages: InspectorData[] = [];
page.on("request", (request) => requests.push(new URL(request.url())));
page.on("pageerror", (error) => errors.push(error.message));
const cursorGate = new Promise<void>((resolve) => {
releaseCursor = resolve;
});
// Hold real cursor responses to measure page 1, without synthetic data or DOM.
await page.route("**/data?**", async (route) => {
if (new URL(route.request().url()).searchParams.has("after"))
await cursorGate;
await route.continue();
});
const initialResponse = page.waitForResponse((response) =>
new URL(response.url()).pathname.endsWith("/data"),
);
const initialCursor = page.waitForRequest((request) =>
new URL(request.url()).searchParams.has("after"),
);
await page.goto(url);
const firstPage: InspectorData = await (await initialResponse).json();
pages.push(firstPage);
await initialCursor;
await browserExpect(page.locator(".entry")).toHaveCount(50);
expect(
await page
.locator("#history")
.evaluate((node) => node.scrollHeight <= node.clientHeight),
).toBe(true);
expect(
await page.locator("#history").evaluate((node) => node.scrollTop),
).toBe(0);
const furtherPages: InspectorData[] = [];
page.on("response", async (response) => {
if (
new URL(response.url()).pathname.endsWith("/data") &&
response.ok()
) {
const snapshot: InspectorData = await response.json();
furtherPages.push(snapshot);
}
});
releaseCursor();
await browserExpect
.poll(() => furtherPages.length)
.toBeGreaterThanOrEqual(2);
await browserExpect(page.locator("#history")).toHaveAttribute(
"aria-busy",
"false",
);
expect(
requests.filter((request) => request.searchParams.has("after")).length,
).toBeGreaterThanOrEqual(2);
const detailRequests = () =>
requests.filter((request) => request.pathname.includes("/entry/"));
expect(detailRequests()).toEqual([]);
expect(
requests.some((request) =>
/\/(?:metrics|prompts)$/u.test(request.pathname),
),
).toBe(false);
const realSummary: InspectorData = await (
await fetch(`${url}data?branch=current&order=newest&limit=50`)
).json();
expect(firstPage.summary).toEqual(realSummary.summary);
expect(firstPage.summary.entries).toBe(manager.getBranch().length);
expect(firstPage.summary.tokens).toBe(25);
expect(firstPage.summary.storedCost).toBe(0.25);
expect(firstPage.entries[0]!.id).toBe(newestId);
const header = await page.locator(".metrics-strip").textContent();
const assertScope = async () => {
expect(await page.locator(".metrics-strip").textContent()).toBe(header);
for (const snapshot of [...pages, ...furtherPages])
expect(snapshot.summary).toEqual(firstPage.summary);
const ids = await page
.locator(".entry")
.evaluateAll((rows) =>
rows.map((row) => (row as HTMLElement).dataset["entryId"]),
);
expect(new Set(ids).size).toBe(ids.length);
};
await page.setViewportSize({ width: 1100, height: 900 });
// Transcript-first screenshots: no dialog or expanded reader obscures the screen.
for (const colorScheme of ["dark", "light"] as const) {
await page.emulateMedia({ colorScheme });
for (const [size, viewport] of [
["desktop", { width: 1100, height: 900 }],
["mobile", { width: 390, height: 844 }],
] as const) {
await page.setViewportSize(viewport);
expect(
await page.evaluate(
() => document.documentElement.scrollWidth <= innerWidth,
),
).toBe(true);
await browserExpect(page.locator("dialog[open]")).toHaveCount(0);
await browserExpect(page.locator(".entry[open]")).toHaveCount(0);
await page.screenshot({
path: join(root, `transcript-${colorScheme}-${size}.png`),
});
}
}
await page.emulateMedia({ colorScheme: "dark" });
await page.setViewportSize({ width: 1100, height: 900 });
const row = page.locator(`.entry[data-entry-id="${newestId}"]`);
const preview = firstPage.entries[0]!.text;
expect(preview).not.toContain("COMPLETE-HISTORY-TAIL-299");
await row.locator(":scope > summary").click();
await browserExpect(
row.locator(".entry-body > .entry-load-status"),
).toHaveText("");
const text = row.locator(".entry-full-text pre");
expect(await text.textContent()).toBe(bodies.get(newestId));
expect((await text.textContent())!.length).toBeGreaterThan(
preview.length,
);
expect(detailRequests().map((request) => request.pathname)).toEqual([
new URL(`entry/${newestId}/text`, url).pathname,
]);
const originalRoot = await text.elementHandle();
const selected = await text.evaluate((node) => {
const range = document.createRange();
range.setStart(node.firstChild!, 0);
range.setEnd(node.firstChild!, 10);
const selection = window.getSelection()!;
selection.removeAllRanges();
selection.addRange(range);
return selection.toString();
});
const originalRange = await page.evaluateHandle(() =>
window.getSelection()!.getRangeAt(0),
);
const scrollPage = async (direction: "after" | "before") => {
const response = page.waitForResponse(
(response) =>
new URL(response.url()).pathname.endsWith("/data") &&
new URL(response.url()).searchParams.has(direction),
);
await page.locator("#history").evaluate((node, side) => {
node.scrollTop = side === "after" ? node.scrollHeight : 0;
}, direction);
pages.push(await (await response).json());
await browserExpect(page.locator("#history")).toHaveAttribute(
"aria-busy",
"false",
);
await assertScope();
expect(
await page.locator(".entry:not([open])").count(),
).toBeLessThanOrEqual(150);
};
for (let step = 0; step < 12; step++) {
if (
(await page.locator("#end-status").textContent()) ===
"End of history."
)
break;
await scrollPage("after");
expect(
await originalRoot!.evaluate(
(node, id) =>
node ===
document.querySelector(
`.entry[data-entry-id="${id}"] .entry-full-text pre`,
),
newestId,
),
).toBe(true);
expect(
await page.evaluate(() => window.getSelection()!.toString()),
).toBe(selected);
expect(
await originalRange.evaluate(
(range) => window.getSelection()!.getRangeAt(0) === range,
),
).toBe(true);
}
await browserExpect(page.locator("#end-status")).toHaveText(
"End of history.",
);
await browserExpect(
page.locator(`.entry[data-entry-id="${oldestId}"]`),
).toHaveCount(1);
expect(
requests.filter((request) => request.searchParams.has("after")).length,
).toBeGreaterThanOrEqual(3);
expect(
await page.locator(".entry:not([open])").count(),
).toBeLessThanOrEqual(150);
expect(detailRequests()).toHaveLength(1);
// Trigger native disclosure without scrolling the pinned reader back into view.
await row
.locator(".entry-json > summary")
.evaluate((node) => (node as HTMLElement).click());
await browserExpect(
row.locator(".entry-json > .entry-load-status"),
).toHaveText("");
expect(detailRequests().map((request) => request.pathname)).toEqual([
new URL(`entry/${newestId}/text`, url).pathname,
new URL(`entry/${newestId}/json`, url).pathname,
]);
expect(
await row.locator(".entry-json .json-code").textContent(),
).toContain("COMPLETE-HISTORY-TAIL-299");
await row
.locator(":scope > summary")
.evaluate((node) => (node as HTMLElement).click());
await page.evaluate(() => {
window.getSelection()!.removeAllRanges();
(document.activeElement as HTMLElement | null)?.blur();
});
// Release the pinned reader before recovering the newest page via before cursors.
for (let step = 0; step < 12; step++) {
if (pages.at(-1)!.page.start === 0) break;
await scrollPage("before");
}
await browserExpect(page.locator(".entry").first()).toHaveAttribute(
"data-entry-id",
newestId,
);
expect(
requests.filter((request) => request.searchParams.has("before")).length,
).toBeGreaterThanOrEqual(3);
await assertScope();
expect(
requests.some((request) =>
/\/(?:metrics|prompts)$/u.test(request.pathname),
),
).toBe(false);
await page.locator("#insights-button").click();
await browserExpect(page.locator("#metrics-status")).toContainText(
"complete scope",
);
expect(
requests.filter((request) => request.pathname.endsWith("/metrics")),
).toHaveLength(1);
expect(
requests.some((request) => request.pathname.endsWith("/prompts")),
).toBe(false);
await page.locator("#insights-panel [data-close]").click();
await page.locator("#session-button").click();
expect(
requests.some((request) => request.pathname.endsWith("/prompts")),
).toBe(false);
await page.locator("#captures > summary").click();
await browserExpect(page.locator("#prompt-empty")).toBeVisible();
expect(
requests.filter((request) => request.pathname.endsWith("/prompts")),
).toHaveLength(1);
expect(
pages.every(
(snapshot) => snapshot.summary.entries === firstPage.summary.entries,
),
).toBe(true);
expect(errors).toEqual([]);
} finally {
releaseCursor();
await browser.close();
await pi?.dispose();
if (keepScreenshots) {
await rm(join(root, "package"), { recursive: true, force: true });
console.log(`History screenshots: ${root}`);
} else await rm(root, { recursive: true, force: true });
}
},
60_000,
);