repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
test/fixture/create-pi-session.test.ts
Rawimport { type ChildProcess, spawn } from "node:child_process";
import { once } from "node:events";
import { access, mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import {
fauxAssistantMessage,
fauxToolCall,
InMemoryCredentialStore,
} from "@earendil-works/pi-ai";
import { SessionManager } from "@earendil-works/pi-coding-agent";
import { Type } from "typebox";
import { afterEach, describe, expect, it } from "vitest";
import { createPiSession, type PiSession } from "./create-pi-session.ts";
let session: PiSession | undefined;
let root: string | undefined;
afterEach(async () => {
await session?.dispose();
session = undefined;
if (root) await rm(root, { recursive: true, force: true });
root = undefined;
});
describe("owned Pi fixture", () => {
it("sets project trust before initial extension startup", async () => {
const trust: boolean[] = [];
session = await createPiSession({
projectTrusted: false,
extensionFactories: [
(pi) => {
pi.on("session_start", (_event, ctx) => {
trust.push(ctx.isProjectTrusted());
});
},
],
});
expect(trust).toEqual([false]);
});
it.each([
{ tools: ["read"] },
{ tools: ["read", "write"], excludeTools: ["write"] },
{ noTools: "all" as const, tools: ["read"] },
])("forwards native tool selection $tools", async (options) => {
session = await createPiSession(options);
expect(session.session.getActiveToolNames()).toEqual(["read"]);
});
it("reopens a caller-owned session from disk without deleting its cwd", async () => {
root = await mkdtemp(join(tmpdir(), "pi-fixture-reopen-"));
const manager = SessionManager.create(root, join(root, "sessions"));
session = await createPiSession({
cwd: root,
sessionManager: manager,
responses: [fauxAssistantMessage("persisted answer")],
});
await session.session.prompt("persisted request");
const file = manager.getSessionFile();
if (!file) throw new Error("missing persisted session");
await session.dispose();
await access(root);
session = await createPiSession({
cwd: root,
sessionManager: SessionManager.open(file),
});
expect(session.session.getLastAssistantText()).toBe("persisted answer");
expect(session.errors).toEqual([]);
});
it("waits for a briefly retained child cwd before deleting owned fixtures", async () => {
let child: ChildProcess | undefined;
session = await createPiSession({
extensionFactories: [
(pi) => {
pi.on("session_shutdown", () => {
setTimeout(() => child?.kill(), 150);
});
},
],
});
const cwd = session.cwd;
child = spawn(
process.execPath,
["-e", "process.stdout.write('ready'); setInterval(() => {}, 1000);"],
{ cwd, stdio: ["ignore", "pipe", "ignore"] },
);
const closed = once(child, "close");
try {
await once(child.stdout!, "data");
await session.dispose();
await closed;
expect(session.errors).toEqual([]);
await expect(access(cwd)).rejects.toMatchObject({ code: "ENOENT" });
} finally {
child.kill();
await closed;
}
});
it("settles active tool cleanup before shutdown and restoring its environment", async () => {
const originalHome = process.env["HOME"];
const started = Promise.withResolvers<void>();
const aborting = Promise.withResolvers<void>();
const release = Promise.withResolvers<void>();
let cleaned = false;
let shutdownAfterCleanup = false;
session = await createPiSession({
extensionFactories: [
(pi) => {
pi.registerTool({
name: "cleanup_probe",
label: "Cleanup probe",
description:
"Wait for cancellation and complete asynchronous cleanup.",
parameters: Type.Object({}),
async execute(_id, _args, signal) {
const aborted = new Promise<void>((resolve) => {
signal!.addEventListener("abort", () => resolve(), {
once: true,
});
});
started.resolve();
await aborted;
aborting.resolve();
await release.promise;
await access(session!.cwd);
expect(process.env["HOME"]).toBe(session!.env["HOME"]);
cleaned = true;
return {
content: [{ type: "text", text: "cleaned" }],
details: undefined,
};
},
});
pi.on("session_shutdown", () => {
shutdownAfterCleanup = cleaned;
});
},
],
responses: [
fauxAssistantMessage(fauxToolCall("cleanup_probe", {}), {
stopReason: "toolUse",
}),
],
});
const cwd = session.cwd;
const turn = session.session.prompt("Run cleanup probe.");
await started.promise;
const disposing = session.dispose();
try {
await aborting.promise;
expect(process.env["HOME"]).toBe(session.env["HOME"]);
await access(cwd);
expect(shutdownAfterCleanup).toBe(false);
} finally {
release.resolve();
await Promise.all([turn, disposing]);
}
expect(cleaned).toBe(true);
expect(shutdownAfterCleanup).toBe(true);
expect(session.errors).toEqual([]);
expect(process.env["HOME"]).toBe(originalHome);
await expect(access(cwd)).rejects.toMatchObject({ code: "ENOENT" });
});
it("surfaces shutdown errors after restoring environment and deleting its owned cwd", async () => {
const originalHome = process.env["HOME"];
session = await createPiSession({
extensionFactories: [
(pi) => {
pi.on("session_shutdown", () => {
throw new Error("shutdown regression evidence");
});
},
],
});
const cwd = session.cwd;
await expect(session.dispose()).rejects.toThrow(
"shutdown regression evidence",
);
expect(process.env["HOME"]).toBe(originalHome);
await expect(access(cwd)).rejects.toMatchObject({ code: "ENOENT" });
});
it("keeps injected credentials and catalog cache off disk", async () => {
session = await createPiSession({
credentials: new InMemoryCredentialStore(),
extensionPaths: [],
responses: [fauxAssistantMessage("in-memory credentials")],
});
await session.session.prompt("hi");
await session.session.modelRuntime.refresh({ allowNetwork: false });
expect(session.errors).toEqual([]);
expect(session.providerState.callCount).toBe(1);
for (const file of ["auth.json", "models-store.json"]) {
await expect(access(join(session.agentDir, file))).rejects.toMatchObject({
code: "ENOENT",
});
}
});
it("drives a scripted model turn through the public provider", async () => {
session = await createPiSession({
extensionPaths: [],
responses: [fauxAssistantMessage("hello from the owned fixture")],
});
await session.session.prompt("hi");
expect(session.errors).toEqual([]);
expect(session.providerState.callCount).toBe(1);
});
});