gsd-pi 2.45.0 → 2.46.0

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

@@ -0,0 +1,227 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { describe, it } from "node:test";
+import {
+	readManifestRuntimeDeps,
+	collectRuntimeDependencies,
+	verifyRuntimeDependencies,
+	resolveLocalSourcePath,
+} from "./lifecycle-hooks.js";
+
+function tmpDir(prefix: string, t: { after: (fn: () => void) => void }): string {
+	const dir = mkdtempSync(join(tmpdir(), `pi-lh-${prefix}-`));
+	t.after(() => rmSync(dir, { recursive: true, force: true }));
+	return dir;
+}
+
+// ─── readManifestRuntimeDeps ──────────────────────────────────────────────────
+
+describe("readManifestRuntimeDeps", () => {
+	it("returns empty array when manifest file is missing", (t) => {
+		const dir = tmpDir("no-manifest", t);
+		assert.deepEqual(readManifestRuntimeDeps(dir), []);
+	});
+
+	it("returns empty array for malformed JSON", (t) => {
+		const dir = tmpDir("bad-json", t);
+		writeFileSync(join(dir, "extension-manifest.json"), "not json{{{", "utf-8");
+		assert.deepEqual(readManifestRuntimeDeps(dir), []);
+	});
+
+	it("returns runtime deps from valid manifest", (t) => {
+		const dir = tmpDir("valid", t);
+		writeFileSync(join(dir, "extension-manifest.json"), JSON.stringify({
+			dependencies: { runtime: ["claude", "node"] },
+		}), "utf-8");
+		assert.deepEqual(readManifestRuntimeDeps(dir), ["claude", "node"]);
+	});
+
+	it("returns empty array when dependencies exists but runtime is missing", (t) => {
+		const dir = tmpDir("no-runtime", t);
+		writeFileSync(join(dir, "extension-manifest.json"), JSON.stringify({
+			dependencies: {},
+		}), "utf-8");
+		assert.deepEqual(readManifestRuntimeDeps(dir), []);
+	});
+
+	it("returns empty array when runtime is empty", (t) => {
+		const dir = tmpDir("empty-runtime", t);
+		writeFileSync(join(dir, "extension-manifest.json"), JSON.stringify({
+			dependencies: { runtime: [] },
+		}), "utf-8");
+		assert.deepEqual(readManifestRuntimeDeps(dir), []);
+	});
+
+	it("filters out non-string entries in runtime array", (t) => {
+		const dir = tmpDir("mixed-types", t);
+		writeFileSync(join(dir, "extension-manifest.json"), JSON.stringify({
+			dependencies: { runtime: [123, null, "node", false, "python"] },
+		}), "utf-8");
+		assert.deepEqual(readManifestRuntimeDeps(dir), ["node", "python"]);
+	});
+
+	it("returns empty array when no dependencies field at all", (t) => {
+		const dir = tmpDir("no-deps-field", t);
+		writeFileSync(join(dir, "extension-manifest.json"), JSON.stringify({
+			id: "test",
+			name: "Test",
+		}), "utf-8");
+		assert.deepEqual(readManifestRuntimeDeps(dir), []);
+	});
+});
+
+// ─── collectRuntimeDependencies ───────────────────────────────────────────────
+
+describe("collectRuntimeDependencies", () => {
+	it("aggregates deps from installedPath manifest", (t) => {
+		const dir = tmpDir("collect-installed", t);
+		writeFileSync(join(dir, "extension-manifest.json"), JSON.stringify({
+			dependencies: { runtime: ["claude"] },
+		}), "utf-8");
+		assert.deepEqual(collectRuntimeDependencies(dir, []), ["claude"]);
+	});
+
+	it("aggregates deps from entry path directory manifests", (t) => {
+		const root = tmpDir("collect-entry", t);
+		const installedDir = join(root, "installed");
+		const entryDir = join(root, "entry");
+		mkdirSync(installedDir, { recursive: true });
+		mkdirSync(entryDir, { recursive: true });
+		writeFileSync(join(entryDir, "extension-manifest.json"), JSON.stringify({
+			dependencies: { runtime: ["python"] },
+		}), "utf-8");
+		const deps = collectRuntimeDependencies(installedDir, [join(entryDir, "index.ts")]);
+		assert.deepEqual(deps, ["python"]);
+	});
+
+	it("deduplicates across multiple directories", (t) => {
+		const root = tmpDir("collect-dedup", t);
+		const dir1 = join(root, "dir1");
+		const dir2 = join(root, "dir2");
+		mkdirSync(dir1, { recursive: true });
+		mkdirSync(dir2, { recursive: true });
+		writeFileSync(join(dir1, "extension-manifest.json"), JSON.stringify({
+			dependencies: { runtime: ["node", "python"] },
+		}), "utf-8");
+		writeFileSync(join(dir2, "extension-manifest.json"), JSON.stringify({
+			dependencies: { runtime: ["python", "claude"] },
+		}), "utf-8");
+		const deps = collectRuntimeDependencies(dir1, [join(dir2, "index.ts")]);
+		assert.equal(deps.length, 3);
+		assert.ok(deps.includes("node"));
+		assert.ok(deps.includes("python"));
+		assert.ok(deps.includes("claude"));
+	});
+
+	it("returns empty when no directories have manifests", (t) => {
+		const dir = tmpDir("collect-empty", t);
+		assert.deepEqual(collectRuntimeDependencies(dir, []), []);
+	});
+});
+
+// ─── verifyRuntimeDependencies ────────────────────────────────────────────────
+
+describe("verifyRuntimeDependencies", () => {
+	it("does not throw for empty deps array", () => {
+		assert.doesNotThrow(() => verifyRuntimeDependencies([], "test-source", "pi"));
+	});
+
+	it("does not throw when all deps are present", () => {
+		assert.doesNotThrow(() => verifyRuntimeDependencies(["node"], "test-source", "pi"));
+	});
+
+	it("throws for missing dep with 'Missing runtime dependencies' message", () => {
+		assert.throws(
+			() => verifyRuntimeDependencies(["__nonexistent_dep_for_test__"], "test-source", "pi"),
+			(err: Error) => {
+				assert.ok(err.message.includes("Missing runtime dependencies"));
+				assert.ok(err.message.includes("__nonexistent_dep_for_test__"));
+				return true;
+			},
+		);
+	});
+
+	it("lists all missing deps in error message", () => {
+		assert.throws(
+			() => verifyRuntimeDependencies(["__missing_1__", "__missing_2__"], "test-source", "pi"),
+			(err: Error) => {
+				assert.ok(err.message.includes("__missing_1__"));
+				assert.ok(err.message.includes("__missing_2__"));
+				return true;
+			},
+		);
+	});
+
+	it("includes appName and source in error for retry hint", () => {
+		assert.throws(
+			() => verifyRuntimeDependencies(["__missing__"], "github:user/repo", "gsd"),
+			(err: Error) => {
+				assert.ok(err.message.includes("gsd"));
+				assert.ok(err.message.includes("github:user/repo"));
+				return true;
+			},
+		);
+	});
+});
+
+// ─── resolveLocalSourcePath ───────────────────────────────────────────────────
+
+describe("resolveLocalSourcePath", () => {
+	it("returns undefined for empty string", () => {
+		assert.equal(resolveLocalSourcePath("", "/tmp"), undefined);
+	});
+
+	it("returns undefined for npm: source", () => {
+		assert.equal(resolveLocalSourcePath("npm:@foo/bar", "/tmp"), undefined);
+	});
+
+	it("returns undefined for git URL", () => {
+		assert.equal(resolveLocalSourcePath("git:github.com/user/repo", "/tmp"), undefined);
+	});
+
+	it("returns undefined for https git URL", () => {
+		assert.equal(resolveLocalSourcePath("https://github.com/user/repo", "/tmp"), undefined);
+	});
+
+	it("resolves ~ to homedir", () => {
+		const result = resolveLocalSourcePath("~", "/tmp");
+		if (existsSync(homedir())) {
+			assert.equal(result, homedir());
+		} else {
+			assert.equal(result, undefined);
+		}
+	});
+
+	it("resolves ~/path relative to homedir", () => {
+		const result = resolveLocalSourcePath("~/", "/tmp");
+		if (existsSync(homedir())) {
+			assert.equal(result, homedir());
+		} else {
+			assert.equal(result, undefined);
+		}
+	});
+
+	it("resolves relative path that exists", (t) => {
+		const dir = tmpDir("resolve-rel", t);
+		const sub = join(dir, "myext");
+		mkdirSync(sub, { recursive: true });
+		const result = resolveLocalSourcePath("myext", dir);
+		assert.equal(result, resolve(dir, "myext"));
+	});
+
+	it("returns undefined for relative path that does not exist", (t) => {
+		const dir = tmpDir("resolve-noexist", t);
+		assert.equal(resolveLocalSourcePath("nonexistent", dir), undefined);
+	});
+
+	it("resolves absolute path that exists", (t) => {
+		const dir = tmpDir("resolve-abs", t);
+		assert.equal(resolveLocalSourcePath(dir, "/irrelevant"), dir);
+	});
+
+	it("returns undefined for absolute path that does not exist", () => {
+		assert.equal(resolveLocalSourcePath("/tmp/__nonexistent_path_for_test__", "/tmp"), undefined);
+	});
+});

package/packages/pi-coding-agent/src/core/lifecycle-hooks.ts

@@ -62,7 +62,7 @@ function toScope(local: boolean): LifecycleHookScope {
 	return local ? "project" : "user";
 }
 
-function readManifestRuntimeDeps(dir: string): string[] {
+export function readManifestRuntimeDeps(dir: string): string[] {
 	const manifestPath = join(dir, "extension-manifest.json");
 	if (!existsSync(manifestPath)) return [];
 	try {
@@ -73,7 +73,7 @@ function readManifestRuntimeDeps(dir: string): string[] {
 	}
 }
 
-function collectRuntimeDependencies(installedPath: string, entryPaths: string[]): string[] {
+export function collectRuntimeDependencies(installedPath: string, entryPaths: string[]): string[] {
 	const deps = new Set<string>();
 	const candidateDirs = new Set<string>([installedPath, ...entryPaths.map((entryPath) => dirname(entryPath))]);
 	for (const dir of candidateDirs) {
@@ -84,7 +84,7 @@ function collectRuntimeDependencies(installedPath: string, entryPaths: string[])
 	return Array.from(deps);
 }
 
-function verifyRuntimeDependencies(runtimeDeps: string[], source: string, appName: string): void {
+export function verifyRuntimeDependencies(runtimeDeps: string[], source: string, appName: string): void {
 	const missing: string[] = [];
 	for (const dep of runtimeDeps) {
 		const result = spawnSync(dep, ["--version"], { encoding: "utf-8", timeout: 5000 });
@@ -99,7 +99,7 @@ function verifyRuntimeDependencies(runtimeDeps: string[], source: string, appNam
 	);
 }
 
-function resolveLocalSourcePath(source: string, cwd: string): string | undefined {
+export function resolveLocalSourcePath(source: string, cwd: string): string | undefined {
 	const trimmed = source.trim();
 	if (!trimmed) return undefined;
 	if (trimmed.startsWith("npm:")) return undefined;
@@ -193,13 +193,19 @@ function getLegacyExportCandidates(phase: LifecycleHookPhase): string[] {
 	return [phase];
 }
 
+const _legacyModuleCache = new Map<string, Record<string, unknown>>();
+
 async function runLegacyExportHook(
 	entryPath: string,
 	phase: LifecycleHookPhase,
 	context: LifecycleHookContext,
 ): Promise<LifecycleHookHandler | null> {
 	try {
-		const module = await importExtensionModule<Record<string, unknown>>(import.meta.url, pathToFileURL(entryPath).href);
+		let module = _legacyModuleCache.get(entryPath);
+		if (!module) {
+			module = await importExtensionModule<Record<string, unknown>>(import.meta.url, pathToFileURL(entryPath).href);
+			_legacyModuleCache.set(entryPath, module);
+		}
 		for (const exportName of getLegacyExportCandidates(phase)) {
 			const candidate = module[exportName];
 			if (typeof candidate === "function") {