import { 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(); const aborting = Promise.withResolvers(); const release = Promise.withResolvers(); 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((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); }); });