gsd-pi 2.43.0 → 2.44.0-dev.62b5d6c

package/packages/pi-coding-agent/src/core/lsp/client.ts

@@ -24,6 +24,17 @@ const clients = new Map<string, LspClient>();
 const clientLocks = new Map<string, Promise<LspClient>>();
 const fileOperationLocks = new Map<string, Promise<void>>();
 
+/** Track stream listeners per client so they can be removed on shutdown. */
+interface StreamHandlers {
+	stdoutData?: (chunk: Buffer) => void;
+	stdoutEnd?: () => void;
+	stdoutError?: () => void;
+	stderrData?: (chunk: Buffer) => void;
+	stderrEnd?: () => void;
+	stderrError?: () => void;
+}
+const clientStreamHandlers = new Map<string, StreamHandlers>();
+
 // Idle timeout configuration (disabled by default)
 let idleTimeoutMs: number | null = null;
 let idleCheckInterval: ReturnType<typeof setInterval> | null = null;
@@ -257,7 +268,9 @@ async function startMessageReader(client: LspClient): Promise<void> {
 	}
 
 	return new Promise<void>((resolve) => {
-		stdout.on("data", async (chunk: Buffer) => {
+		const handlers = clientStreamHandlers.get(client.name) ?? {};
+
+		handlers.stdoutData = async (chunk: Buffer) => {
 			const currentBuffer: Buffer = Buffer.concat([client.messageBuffer, chunk]);
 
 			if (currentBuffer.length > MAX_MESSAGE_BUFFER_SIZE) {
@@ -307,17 +320,22 @@ async function startMessageReader(client: LspClient): Promise<void> {
 			}
 
 			client.messageBuffer = workingBuffer;
-		});
+		};
+		stdout.on("data", handlers.stdoutData);
 
-		stdout.on("end", () => {
+		handlers.stdoutEnd = () => {
 			client.isReading = false;
 			resolve();
-		});
+		};
+		stdout.on("end", handlers.stdoutEnd);
 
-		stdout.on("error", () => {
+		handlers.stdoutError = () => {
 			client.isReading = false;
 			resolve();
-		});
+		};
+		stdout.on("error", handlers.stdoutError);
+
+		clientStreamHandlers.set(client.name, handlers);
 	});
 }
 
@@ -402,21 +420,28 @@ async function startStderrReader(client: LspClient): Promise<void> {
 	if (!stderr) return;
 
 	return new Promise<void>((resolve) => {
-		stderr.on("data", (chunk: Buffer) => {
+		const handlers = clientStreamHandlers.get(client.name) ?? {};
+
+		handlers.stderrData = (chunk: Buffer) => {
 			const text = chunk.toString("utf-8");
 			client.stderrBuffer += text;
 			if (client.stderrBuffer.length > 4096) {
 				client.stderrBuffer = client.stderrBuffer.slice(-4096);
 			}
-		});
+		};
+		stderr.on("data", handlers.stderrData);
 
-		stderr.on("end", () => {
+		handlers.stderrEnd = () => {
 			resolve();
-		});
+		};
+		stderr.on("end", handlers.stderrEnd);
 
-		stderr.on("error", () => {
+		handlers.stderrError = () => {
 			resolve();
-		});
+		};
+		stderr.on("error", handlers.stderrError);
+
+		clientStreamHandlers.set(client.name, handlers);
 	});
 }
 
@@ -706,6 +731,23 @@ export function notifyFileChanged(filePath: string): void {
 	}
 }
 
+/**
+ * Remove stdout/stderr stream listeners for a client to prevent leaks.
+ */
+function removeStreamHandlers(client: LspClient): void {
+	const handlers = clientStreamHandlers.get(client.name);
+	if (!handlers) return;
+
+	if (handlers.stdoutData) client.proc.stdout?.removeListener("data", handlers.stdoutData);
+	if (handlers.stdoutEnd) client.proc.stdout?.removeListener("end", handlers.stdoutEnd);
+	if (handlers.stdoutError) client.proc.stdout?.removeListener("error", handlers.stdoutError);
+	if (handlers.stderrData) client.proc.stderr?.removeListener("data", handlers.stderrData);
+	if (handlers.stderrEnd) client.proc.stderr?.removeListener("end", handlers.stderrEnd);
+	if (handlers.stderrError) client.proc.stderr?.removeListener("error", handlers.stderrError);
+
+	clientStreamHandlers.delete(client.name);
+}
+
 /**
  * Shutdown a specific client by key.
  */
@@ -720,6 +762,9 @@ function shutdownClient(key: string): void {
 
 	sendRequest(client, "shutdown", null).catch(() => {});
 
+	// Remove stream listeners before killing the process
+	removeStreamHandlers(client);
+
 	try {
 		killProcessTree(client.proc.pid);
 	} catch {
@@ -860,6 +905,9 @@ function shutdownAll(): void {
 			pending.reject(err);
 		}
 
+		// Remove stream listeners before killing the process
+		removeStreamHandlers(client);
+
 		void (async () => {
 			const timeout = new Promise<void>(resolve => setTimeout(resolve, 5_000));
 			const result = sendRequest(client, "shutdown", null).catch(() => {});
@@ -893,14 +941,28 @@ export function getActiveClients(): LspServerStatus[] {
 // Process Cleanup
 // =============================================================================
 
+const _beforeExitHandler = () => shutdownAll();
+const _sigintHandler = () => {
+	shutdownAll();
+	process.exit(0);
+};
+const _sigtermHandler = () => {
+	shutdownAll();
+	process.exit(0);
+};
+
 if (typeof process !== "undefined") {
-	process.on("beforeExit", shutdownAll);
-	process.on("SIGINT", () => {
-		shutdownAll();
-		process.exit(0);
-	});
-	process.on("SIGTERM", () => {
-		shutdownAll();
-		process.exit(0);
-	});
+	process.on("beforeExit", _beforeExitHandler);
+	process.on("SIGINT", _sigintHandler);
+	process.on("SIGTERM", _sigtermHandler);
+}
+
+/**
+ * Remove process-level signal handlers registered at module load.
+ * Call this during graceful teardown to prevent leaked listeners.
+ */
+export function removeProcessHandlers(): void {
+	process.off("beforeExit", _beforeExitHandler);
+	process.off("SIGINT", _sigintHandler);
+	process.off("SIGTERM", _sigtermHandler);
 }

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;