repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/bak/__tests__/tool.test.ts
Rawimport { access } from "node:fs/promises";
import { fileURLToPath } from "node:url";
import { fauxAssistantMessage, fauxToolCall } from "@earendil-works/pi-ai";
import {
createCodemodeExtension,
estimateTokens,
initTheme,
} from "@earendil-works/pi-coding-agent";
import { Value } from "typebox/value";
import { afterEach, describe, expect, it, vi } from "vitest";
import {
createPiSession,
type PiSession,
} from "../../../test/fixture/create-pi-session.ts";
import { statePaths } from "../state.js";
import { BakOutput, BakParameters } from "../tool.js";
const HOST = "12345678-1234-1234-1234-123456789abc";
const SESSION = "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa";
const OTHER_SESSION = "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb";
const DATE = "2026-01-01T00:00:00.000Z";
const ACCESS = "TEST_ARCHIVE_ACCESS_CREDENTIAL";
const FAKE_CREDENTIAL = "test-secret";
const archiveEnv = {
PI_BAK_AUTO_BACKUP: "false",
PI_BAK_DEBUG: "0",
PI_BAK_S3_ENDPOINT: "https://example.invalid",
PI_BAK_S3_BUCKET: "bucket",
PI_BAK_S3_ACCESS_KEY_ID: ACCESS,
PI_BAK_S3_SECRET_ACCESS_KEY: FAKE_CREDENTIAL,
};
const entry = fileURLToPath(new URL("../index.ts", import.meta.url));
let fixture: PiSession | undefined;
function fakeStorage() {
const objects = new Map<string, string>([
[
"catalog/hosts.json",
JSON.stringify({
version: 1,
hosts: [{ hostId: HOST, alias: "desktop" }],
}),
],
[
`hosts/${HOST}.json`,
JSON.stringify({
version: 1,
hostId: HOST,
alias: "desktop",
sessions: [SESSION, OTHER_SESSION].map((id) => ({
id,
key: `sessions/${HOST}/${id}.jsonl`,
name: `Archive ${id}`,
cwd: "/work/project",
created: DATE,
})),
}),
],
[
`sessions/${HOST}/${SESSION}.jsonl`,
[
{
type: "session",
version: 3,
id: SESSION,
timestamp: DATE,
cwd: "/work/project",
},
{
type: "message",
id: "one",
parentId: null,
timestamp: DATE,
message: { role: "user", content: `historical ${FAKE_CREDENTIAL}` },
},
]
.map((value) => JSON.stringify(value))
.join("\n"),
],
]);
const calls: string[] = [];
const fetch = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
const request = new Request(input, init);
expect(request.method).toBe("GET");
const key = decodeURIComponent(
new URL(request.url).pathname.slice("/bucket/".length),
);
calls.push(key);
const body = objects.get(key);
const range = request.headers.get("range");
if (body !== undefined && range) {
const bytes = Buffer.from(body);
const match = /^bytes=(\d+)-(\d+)$/.exec(range)!;
const start = Number(match[1]),
end = Math.min(Number(match[2]), bytes.length - 1);
if (start >= bytes.length) return new Response(null, { status: 416 });
return new Response(
Uint8Array.from(bytes.subarray(start, end + 1)).buffer,
{
status: 206,
headers: {
etag: '"stable"',
"content-range": `bytes ${start}-${end}/${bytes.length}`,
},
},
);
}
return new Response(body ?? "missing", {
status: body === undefined ? 404 : 200,
});
});
vi.stubGlobal("fetch", fetch);
return { objects, calls, fetch };
}
async function start(codemode = false) {
initTheme(undefined, false);
fixture = await createPiSession({
extensionPaths: [entry],
extensionFactories: codemode ? [createCodemodeExtension()] : [],
userSettings: {
bak: { autoBackup: false },
defaultTools: codemode
? ["+codemode"]
: ["read", "bash", "edit", "write"],
},
env: archiveEnv,
});
const tool = fixture.extensions
.find((extension) => extension.path === entry)
?.tools.get("bak")?.definition;
if (!tool) throw new Error("missing bak tool");
const invoke = (
params: Parameters<typeof tool.execute>[1],
signal?: AbortSignal,
) =>
tool.execute(
"query-test",
params,
signal,
undefined,
fixture!.session.extensionRunner.createToolContext("query-test", signal),
);
return { tool, invoke };
}
afterEach(async () => {
await fixture?.dispose();
fixture = undefined;
vi.unstubAllGlobals();
vi.restoreAllMocks();
});
describe("bak agent query tool", () => {
it("registers callable codemode exposure and read-only hints without startup I/O", async () => {
const storage = fakeStorage();
const { tool } = await start();
expect(tool.exposure).toBe("codemode");
expect(tool.annotations).toEqual({
readOnlyHint: true,
destructiveHint: false,
idempotentHint: true,
openWorldHint: true,
});
expect(tool.outputSchema).toBeDefined();
expect(fixture!.session.getActiveToolNames()).not.toContain("bak");
expect(fixture!.session.getCallableToolNames()).toContain("bak");
expect(storage.fetch).not.toHaveBeenCalled();
});
it("measures first-request heuristic context impact without live provider calls", async () => {
const storage = fakeStorage();
const measurements: { tokens: number; tools: string[] }[] = [];
for (const withBak of [false, true]) {
fixture = await createPiSession({
extensionPaths: withBak ? [entry] : [],
extensionFactories: [createCodemodeExtension()],
userSettings: {
bak: { autoBackup: false },
defaultTools: ["+codemode"],
},
env: archiveEnv,
responses: [
(context) => {
measurements.push({
tokens: context.messages.reduce(
(total, message) => total + estimateTokens(message),
0,
),
tools: context.messages.flatMap((message) =>
message.role === "system"
? (message.toolsAdded ?? []).map((tool) => tool.name)
: [],
),
});
return fauxAssistantMessage("OK");
},
],
});
await fixture.session.prompt("Reply only OK. Do not use tools.");
expect(fixture.errors).toEqual([]);
await fixture.dispose();
fixture = undefined;
}
expect(measurements).toHaveLength(2);
expect(measurements[1]!.tools).toEqual(measurements[0]!.tools);
expect(storage.fetch).not.toHaveBeenCalled();
console.info(
"Bak isolated first-request SDK heuristic tokens (not provider-reported)",
{
withoutBak: measurements[0]!.tokens,
withBak: measurements[1]!.tokens,
delta: measurements[1]!.tokens - measurements[0]!.tokens,
},
);
});
it("lists/searches/reads without cache, identity, restore files or remote writes", async () => {
const storage = fakeStorage();
const { invoke } = await start();
const listed = await invoke({ action: "list", limit: 1 });
expect(Value.Check(BakOutput, listed.structuredContent)).toBe(true);
const searched = await invoke({ action: "search", query: "project" });
expect(Value.Check(BakOutput, searched.structuredContent)).toBe(true);
const read = await invoke({
action: "read",
hostId: HOST,
sessionId: SESSION,
});
expect(Value.Check(BakOutput, read.structuredContent)).toBe(true);
const text = JSON.stringify(read);
expect(text).toContain("historical [redacted]");
expect(text).not.toContain(FAKE_CREDENTIAL);
expect(text).not.toContain(ACCESS);
expect(text).not.toContain(`sessions/${HOST}/`);
const paths = statePaths();
for (const path of [paths.identity, paths.cache, paths.pendingDir])
await expect(access(path)).rejects.toMatchObject({ code: "ENOENT" });
expect(storage.calls).toContain(`sessions/${HOST}/${SESSION}.jsonl`);
expect(fixture!.errors).toEqual([]);
});
it("exposes full archived entries on demand through the registered tool without writes", async () => {
const storage = fakeStorage();
const key = `sessions/${HOST}/${SESSION}.jsonl`;
const original = storage.objects.get(key)!;
storage.objects.set(
key,
`${original}\n${JSON.stringify({ type: "compaction", details: { decay: { elapsedMs: 1234, atoms: [{ key: "rule" }] } }, summary: "checkpoint" })}\n${JSON.stringify({ type: "custom", customType: "decay-diagnostic", data: { reason: "failure", credential: ACCESS } })}\n${JSON.stringify(
{
type: "message",
message: {
role: "assistant",
content: [
{ type: "thinking", thinking: "reasoning" },
{ type: "toolCall", arguments: { value: "x".repeat(20000) } },
],
},
},
)}`,
);
const { invoke } = await start();
let result = await invoke({
action: "read",
view: "raw-jsonl",
hostId: HOST,
sessionId: SESSION,
});
let restored = "";
while (true) {
expect(Value.Check(BakOutput, result.structuredContent)).toBe(true);
const page =
result.structuredContent as import("../tool.js").BakRawResult;
restored += page.text;
if (!page.nextCursor) break;
result = await invoke({ action: "read", cursor: page.nextCursor });
}
const entries = restored.split("\n").map((line) => JSON.parse(line));
expect(entries[2].details.decay).toEqual({
elapsedMs: 1234,
atoms: [{ key: "rule" }],
});
expect(entries[3].customType).toBe("decay-diagnostic");
expect(entries[4].message.content[0].thinking).toBe("reasoning");
expect(entries[4].message.content[1].arguments.value).toHaveLength(20000);
expect(restored).not.toContain(ACCESS);
expect(restored).not.toContain(FAKE_CREDENTIAL);
const paths = statePaths();
for (const path of [paths.identity, paths.cache, paths.pendingDir])
await expect(access(path)).rejects.toMatchObject({ code: "ENOENT" });
});
it("returns structured values through a real codemode call", async () => {
fakeStorage();
await start(true);
fixture!.setResponses([
fauxAssistantMessage(
fauxToolCall("codemode", {
code: 'const page = await tools.bak({ action: "list", limit: 1 }); if (typeof page === "string") throw new Error("not structured"); text({ total: page.totalItems, id: page.sessions[0].sessionId });',
}),
{ stopReason: "toolUse" },
),
fauxAssistantMessage("done"),
]);
await fixture!.session.prompt("query the test archive");
const result = fixture!.session.messages.find(
(message) =>
message.role === "toolResult" && message.toolName === "codemode",
);
expect(result?.role).toBe("toolResult");
if (result?.role !== "toolResult")
throw new Error("missing codemode result");
expect(result.isError).toBe(false);
const text = result.content
.filter((item) => item.type === "text")
.map((item) => item.text)
.join("\n");
expect(text).toContain('"total":2');
expect(text).toContain(SESSION);
expect(fixture!.session.getActiveToolNames()).not.toContain("bak");
expect(fixture!.errors).toEqual([]);
});
it("rejects unsafe or irrelevant parameters before execution", () => {
for (const params of [
{ action: "restore" },
{ action: "read", hostId: "../other", sessionId: SESSION },
{ action: "list", path: "/tmp/restore" },
{ action: "list", limit: 101 },
{ action: "read", cursor: "x", hostId: HOST },
])
expect(Value.Check(BakParameters, params)).toBe(false);
});
it("clears pagination snapshots on shutdown without automatic backup", async () => {
fakeStorage();
const { invoke } = await start();
const result = await invoke({ action: "list", limit: 1 });
const data = result.structuredContent as { nextCursor: string };
await fixture!.session.extensionRunner.emit({
type: "session_shutdown",
reason: "reload",
});
await expect(
invoke({ action: "list", cursor: data.nextCursor }),
).rejects.toThrow("cancelled");
});
it("rejects catalog host limits before fetching any indexes", async () => {
const storage = fakeStorage();
storage.objects.set(
"catalog/hosts.json",
JSON.stringify({
version: 1,
hosts: Array.from({ length: 257 }, (_, i) => ({
hostId: `${i.toString(16).padStart(8, "0")}-1234-1234-1234-123456789abc`,
alias: `host-${i}`,
})),
}),
);
const { invoke } = await start();
await expect(invoke({ action: "list" })).rejects.toThrow("safety limit");
expect(storage.calls).toEqual(["catalog/hosts.json"]);
});
it("rejects oversized transcript lines explicitly", async () => {
const storage = fakeStorage();
const key = `sessions/${HOST}/${SESSION}.jsonl`;
storage.objects.set(
key,
`${storage.objects.get(key)!.split("\n")[0]}\n${JSON.stringify({ type: "message", message: { role: "user", content: "x".repeat(1024 * 1024) } })}`,
);
const { invoke } = await start();
await expect(
invoke({ action: "read", hostId: HOST, sessionId: SESSION }),
).rejects.toThrow("safety limit");
});
it("does not follow object keys supplied by a malicious host index", async () => {
const storage = fakeStorage();
storage.objects.set(
`hosts/${HOST}.json`,
JSON.stringify({
version: 1,
hostId: HOST,
alias: "desktop",
sessions: [
{
id: SESSION,
key: "private/credential-file",
cwd: "/work",
created: DATE,
},
],
}),
);
const { invoke } = await start();
await expect(
invoke({ action: "read", hostId: HOST, sessionId: SESSION }),
).rejects.toThrow("unavailable or invalid");
expect(storage.calls).not.toContain("private/credential-file");
});
it.each(["shutdown", "deadline"])(
"aborts active archive body reads on %s",
async (reason) => {
const storage = fakeStorage();
const { invoke } = await start();
const deadline = new AbortController();
const timeout = AbortSignal.timeout.bind(AbortSignal);
if (reason === "deadline")
vi.spyOn(AbortSignal, "timeout").mockImplementation((ms) =>
ms === 60_000 ? deadline.signal : timeout(ms),
);
const reading = Promise.withResolvers<void>();
let pulls = 0;
const stream = new ReadableStream<Uint8Array>({
pull(controller) {
if (++pulls === 1) controller.enqueue(Buffer.from("{"));
else reading.resolve();
},
});
storage.fetch.mockImplementation(async () => new Response(stream));
const pending = expect(invoke({ action: "list" })).rejects.toThrow(
"cancelled or deadline exceeded",
);
await reading.promise;
if (reason === "shutdown")
await fixture!.session.extensionRunner.emit({
type: "session_shutdown",
reason: "reload",
});
else deadline.abort(new Error("test deadline"));
await pending;
},
);
it("keeps transcript content hidden in collapsed tool rows", async () => {
fakeStorage();
const { tool, invoke } = await start();
const result = await invoke({
action: "read",
hostId: HOST,
sessionId: SESSION,
});
const theme = fixture!.session.extensionRunner.createContext().ui.theme;
const renderContext = { isError: false } as Parameters<
NonNullable<typeof tool.renderResult>
>[3];
const collapsed = tool
.renderResult?.(
result,
{ expanded: false, isPartial: false },
theme,
renderContext,
)
?.render(100)
.join("\n");
const expanded = tool
.renderResult?.(
result,
{ expanded: true, isPartial: false },
theme,
renderContext,
)
?.render(100)
.join("\n");
expect(collapsed).not.toContain("historical");
expect(collapsed).toContain("to expand");
expect(expanded).toContain("historical");
});
});