Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

test/fixture/create-pi-session.test.ts

Raw
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<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);
	});
});