gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/packages/pi-coding-agent/src/core/model-registry-auth-mode.test.ts

@@ -0,0 +1,288 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { Api, Model } from "@gsd/pi-ai";
+import type { AuthStorage } from "./auth-storage.js";
+import { ModelRegistry } from "./model-registry.js";
+
+function createRegistry(hasAuthFn?: (provider: string) => boolean): ModelRegistry {
+	const authStorage = {
+		setFallbackResolver: () => {},
+		onCredentialChange: () => {},
+		getOAuthProviders: () => [],
+		get: () => undefined,
+		hasAuth: hasAuthFn ?? (() => false),
+		getApiKey: async () => undefined,
+	} as unknown as AuthStorage;
+
+	return new ModelRegistry(authStorage, undefined);
+}
+
+function createProviderModel(id: string): NonNullable<Parameters<ModelRegistry["registerProvider"]>[1]["models"]>[number] {
+	return {
+		id,
+		name: id,
+		api: "openai-completions",
+		reasoning: false,
+		input: ["text"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 128000,
+		maxTokens: 16384,
+	};
+}
+
+function findModel(registry: ModelRegistry, provider: string, id: string): Model<Api> | undefined {
+	return registry.getAvailable().find((m) => m.provider === provider && m.id === id);
+}
+
+// ─── Registration ─────────────────────────────────────────────────────────────
+
+describe("ModelRegistry authMode — registration", () => {
+	it("registers externalCli provider without apiKey/oauth", () => {
+		const registry = createRegistry();
+		assert.doesNotThrow(() => {
+			registry.registerProvider("cli-provider", {
+				authMode: "externalCli",
+				baseUrl: "https://cli.local",
+				api: "openai-completions",
+				models: [createProviderModel("cli-model")],
+			});
+		});
+	});
+
+	it("registers none provider without apiKey/oauth", () => {
+		const registry = createRegistry();
+		assert.doesNotThrow(() => {
+			registry.registerProvider("none-provider", {
+				authMode: "none",
+				baseUrl: "http://localhost:11434",
+				api: "openai-completions",
+				models: [createProviderModel("local-model")],
+			});
+		});
+	});
+
+	it("rejects apiKey provider without apiKey or oauth", () => {
+		const registry = createRegistry();
+		assert.throws(() => {
+			registry.registerProvider("apikey-provider", {
+				authMode: "apiKey",
+				baseUrl: "https://api.local",
+				api: "openai-completions",
+				models: [createProviderModel("model")],
+			});
+		});
+	});
+
+	it("rejects provider with no authMode and no apiKey/oauth (defaults to apiKey)", () => {
+		const registry = createRegistry();
+		assert.throws(() => {
+			registry.registerProvider("bare-provider", {
+				baseUrl: "https://api.local",
+				api: "openai-completions",
+				models: [createProviderModel("model")],
+			});
+		});
+	});
+});
+
+// ─── getProviderAuthMode ──────────────────────────────────────────────────────
+
+describe("ModelRegistry authMode — getProviderAuthMode", () => {
+	it("returns apiKey for unregistered (built-in) providers", () => {
+		const registry = createRegistry();
+		assert.equal(registry.getProviderAuthMode("anthropic"), "apiKey");
+	});
+
+	it("returns explicit authMode when set", () => {
+		const registry = createRegistry();
+		registry.registerProvider("cli", {
+			authMode: "externalCli",
+			baseUrl: "https://cli.local",
+			api: "openai-completions",
+			models: [createProviderModel("m")],
+		});
+		assert.equal(registry.getProviderAuthMode("cli"), "externalCli");
+	});
+
+	it("returns none when authMode is none", () => {
+		const registry = createRegistry();
+		registry.registerProvider("local", {
+			authMode: "none",
+			baseUrl: "http://localhost:11434",
+			api: "openai-completions",
+			models: [createProviderModel("m")],
+		});
+		assert.equal(registry.getProviderAuthMode("local"), "none");
+	});
+});
+
+// ─── isProviderRequestReady ───────────────────────────────────────────────────
+
+describe("ModelRegistry authMode — isProviderRequestReady", () => {
+	it("returns true for externalCli without stored auth", () => {
+		const registry = createRegistry(() => false);
+		registry.registerProvider("cli", {
+			authMode: "externalCli",
+			baseUrl: "https://cli.local",
+			api: "openai-completions",
+			models: [createProviderModel("m")],
+		});
+		assert.equal(registry.isProviderRequestReady("cli"), true);
+	});
+
+	it("returns true for none without stored auth", () => {
+		const registry = createRegistry(() => false);
+		registry.registerProvider("local", {
+			authMode: "none",
+			baseUrl: "http://localhost:11434",
+			api: "openai-completions",
+			models: [createProviderModel("m")],
+		});
+		assert.equal(registry.isProviderRequestReady("local"), true);
+	});
+
+	it("returns false for apiKey provider without stored auth", () => {
+		const registry = createRegistry(() => false);
+		assert.equal(registry.isProviderRequestReady("anthropic"), false);
+	});
+
+	it("returns true for apiKey provider with stored auth", () => {
+		const registry = createRegistry(() => true);
+		assert.equal(registry.isProviderRequestReady("anthropic"), true);
+	});
+});
+
+// ─── isReady callback ─────────────────────────────────────────────────────────
+
+describe("ModelRegistry authMode — isReady callback", () => {
+	it("calls isReady and returns its result for externalCli provider", () => {
+		const registry = createRegistry(() => false);
+		registry.registerProvider("cli-down", {
+			authMode: "externalCli",
+			baseUrl: "https://cli.local",
+			api: "openai-completions",
+			isReady: () => false,
+			models: [createProviderModel("m")],
+		});
+		assert.equal(registry.isProviderRequestReady("cli-down"), false);
+	});
+
+	it("calls isReady for apiKey provider (overrides hasAuth)", () => {
+		const registry = createRegistry(() => true);
+		registry.registerProvider("strict-provider", {
+			apiKey: "MY_KEY",
+			baseUrl: "https://api.local",
+			api: "openai-completions",
+			isReady: () => false,
+			models: [createProviderModel("m")],
+		});
+		assert.equal(registry.isProviderRequestReady("strict-provider"), false);
+	});
+
+	it("isReady returning true makes provider available", () => {
+		const registry = createRegistry(() => false);
+		registry.registerProvider("healthy-cli", {
+			authMode: "externalCli",
+			baseUrl: "https://cli.local",
+			api: "openai-completions",
+			isReady: () => true,
+			models: [createProviderModel("m")],
+		});
+		assert.equal(registry.isProviderRequestReady("healthy-cli"), true);
+	});
+
+	it("falls through to default behavior when isReady not provided", () => {
+		const registry = createRegistry(() => false);
+		registry.registerProvider("no-callback", {
+			authMode: "externalCli",
+			baseUrl: "https://cli.local",
+			api: "openai-completions",
+			models: [createProviderModel("m")],
+		});
+		// externalCli without isReady → true (default)
+		assert.equal(registry.isProviderRequestReady("no-callback"), true);
+	});
+});
+
+// ─── getAvailable ─────────────────────────────────────────────────────────────
+
+describe("ModelRegistry authMode — getAvailable", () => {
+	it("includes externalCli models without stored auth", () => {
+		const registry = createRegistry(() => false);
+		registry.registerProvider("cli", {
+			authMode: "externalCli",
+			baseUrl: "https://cli.local",
+			api: "openai-completions",
+			models: [createProviderModel("cli-model")],
+		});
+		assert.ok(findModel(registry, "cli", "cli-model"));
+	});
+
+	it("includes none models without stored auth", () => {
+		const registry = createRegistry(() => false);
+		registry.registerProvider("local", {
+			authMode: "none",
+			baseUrl: "http://localhost:11434",
+			api: "openai-completions",
+			models: [createProviderModel("local-model")],
+		});
+		assert.ok(findModel(registry, "local", "local-model"));
+	});
+
+	it("excludes externalCli models when isReady returns false", () => {
+		const registry = createRegistry(() => false);
+		registry.registerProvider("cli-down", {
+			authMode: "externalCli",
+			baseUrl: "https://cli.local",
+			api: "openai-completions",
+			isReady: () => false,
+			models: [createProviderModel("m")],
+		});
+		assert.equal(findModel(registry, "cli-down", "m"), undefined);
+	});
+
+	it("excludes apiKey models without stored auth", () => {
+		const registry = createRegistry(() => false);
+		// Built-in providers have no registeredProviders entry, so authMode defaults to apiKey
+		// getAvailable filters by isProviderRequestReady → hasAuth → false
+		const available = registry.getAvailable();
+		// No models should be available since hasAuth returns false for everything
+		assert.equal(available.length, 0);
+	});
+});
+
+// ─── getApiKey ────────────────────────────────────────────────────────────────
+
+describe("ModelRegistry authMode — getApiKey", () => {
+	it("returns undefined for externalCli provider", async () => {
+		const registry = createRegistry();
+		registry.registerProvider("cli", {
+			authMode: "externalCli",
+			baseUrl: "https://cli.local",
+			api: "openai-completions",
+			models: [createProviderModel("m")],
+		});
+		const model = registry.getAll().find((m) => m.provider === "cli")!;
+		assert.equal(await registry.getApiKey(model), undefined);
+	});
+
+	it("returns undefined for none provider", async () => {
+		const registry = createRegistry();
+		registry.registerProvider("local", {
+			authMode: "none",
+			baseUrl: "http://localhost:11434",
+			api: "openai-completions",
+			models: [createProviderModel("m")],
+		});
+		const model = registry.getAll().find((m) => m.provider === "local")!;
+		assert.equal(await registry.getApiKey(model), undefined);
+	});
+
+	it("delegates to authStorage for apiKey provider", async () => {
+		const registry = createRegistry();
+		// authStorage.getApiKey returns undefined (no key configured)
+		// For apiKey providers this is an expected "no key" response, not early exit
+		const key = await registry.getApiKeyForProvider("anthropic");
+		assert.equal(key, undefined);
+	});
+});

package/packages/pi-coding-agent/src/core/model-registry.ts

@@ -128,6 +128,8 @@ ajv.addSchema(ModelsConfigSchema, "ModelsConfig");
 
 type ModelsConfig = Static<typeof ModelsConfigSchema>;
 
+export type ProviderAuthMode = "apiKey" | "oauth" | "externalCli" | "none";
+
 /** Provider override config (baseUrl, headers, apiKey) without custom models */
 interface ProviderOverride {
 	baseUrl?: string;
@@ -513,7 +515,31 @@ export class ModelRegistry {
 	 * This is a fast check that doesn't refresh OAuth tokens.
 	 */
 	getAvailable(): Model<Api>[] {
-		return this.models.filter((m) => this.authStorage.hasAuth(m.provider));
+		return this.models.filter((m) => this.isProviderRequestReady(m.provider));
+	}
+
+	/**
+	 * Get auth mode for a provider.
+	 * Defaults to "apiKey" for built-ins and providers without explicit mode.
+	 */
+	getProviderAuthMode(provider: string): ProviderAuthMode {
+		const config = this.registeredProviders.get(provider);
+		if (!config) return "apiKey";
+		if (config.authMode) return config.authMode;
+		if (config.oauth) return "oauth";
+		if (config.apiKey) return "apiKey";
+		return "apiKey";
+	}
+
+	/**
+	 * Whether a provider can be used for requests/fallback without hard auth gating.
+	 */
+	isProviderRequestReady(provider: string): boolean {
+		const config = this.registeredProviders.get(provider);
+		if (config?.isReady) return config.isReady();
+		const authMode = this.getProviderAuthMode(provider);
+		if (authMode === "externalCli" || authMode === "none") return true;
+		return this.authStorage.hasAuth(provider);
 	}
 
 	/**
@@ -525,17 +551,23 @@ export class ModelRegistry {
 
 	/**
 	 * Get API key for a model.
+	 * Returns undefined for externalCli/none providers (no key needed).
 	 * @param sessionId - Optional session ID for sticky credential selection
 	 */
 	async getApiKey(model: Model<Api>, sessionId?: string): Promise<string | undefined> {
+		const authMode = this.getProviderAuthMode(model.provider);
+		if (authMode === "externalCli" || authMode === "none") return undefined;
 		return this.authStorage.getApiKey(model.provider, sessionId);
 	}
 
 	/**
 	 * Get API key for a provider.
+	 * Returns undefined for externalCli/none providers (no key needed).
 	 * @param sessionId - Optional session ID for sticky credential selection
 	 */
 	async getApiKeyForProvider(provider: string, sessionId?: string): Promise<string | undefined> {
+		const authMode = this.getProviderAuthMode(provider);
+		if (authMode === "externalCli" || authMode === "none") return undefined;
 		return this.authStorage.getApiKey(provider, sessionId);
 	}
 
@@ -614,7 +646,8 @@ export class ModelRegistry {
 			if (!config.baseUrl) {
 				throw new Error(`Provider ${providerName}: "baseUrl" is required when defining models.`);
 			}
-			if (!config.apiKey && !config.oauth) {
+			const authMode = config.authMode ?? (config.oauth ? "oauth" : config.apiKey ? "apiKey" : "apiKey");
+			if (authMode === "apiKey" && !config.apiKey && !config.oauth) {
 				throw new Error(`Provider ${providerName}: "apiKey" or "oauth" is required when defining models.`);
 			}
 
@@ -702,7 +735,7 @@ export class ModelRegistry {
 
 			try {
 				const apiKey = await this.authStorage.getApiKey(providerName);
-				if (!apiKey && providerName !== "ollama") continue;
+				if (!apiKey && !this.isProviderRequestReady(providerName)) continue;
 
 				const models = await adapter.fetchModels(apiKey ?? "", undefined);
 				this.discoveryCache.set(providerName, models);
@@ -780,6 +813,9 @@ export class ModelRegistry {
  * Input type for registerProvider API.
  */
 export interface ProviderConfigInput {
+	authMode?: ProviderAuthMode;
+	/** Optional readiness check. Called by isProviderRequestReady() before default auth checks. */
+	isReady?: () => boolean;
 	baseUrl?: string;
 	apiKey?: string;
 	api?: Api;

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