gsd-pi 2.43.0 → 2.44.0-dev.62b5d6c

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

@@ -0,0 +1,240 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Writable } from "node:stream";
+import { describe, it } from "node:test";
+import { runPackageCommand } from "./package-commands.js";
+
+function createCaptureStream() {
+	let output = "";
+	const stream = new Writable({
+		write(chunk, _encoding, callback) {
+			output += chunk.toString();
+			callback();
+		},
+	}) as unknown as NodeJS.WriteStream;
+	return { stream, getOutput: () => output };
+}
+
+function writePackage(root: string, files: Record<string, string>): void {
+	for (const [relPath, content] of Object.entries(files)) {
+		const abs = join(root, relPath);
+		mkdirSync(join(abs, ".."), { recursive: true });
+		writeFileSync(abs, content, "utf-8");
+	}
+}
+
+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("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("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("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 });
+		}
+	});
+});

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/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/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