oh-my-opencode 5.0.0-beta.30 → 5.0.0-beta.31

package/packages/lsp-core/src/lsp/manager-lifecycle.test.ts

@@ -0,0 +1,262 @@
+import { describe, expect, it } from "bun:test";
+
+import type { LspClient } from "./client.js";
+import { LspManager } from "./manager.js";
+import type { ResolvedServer } from "./types.js";
+
+const SERVER: ResolvedServer = {
+	id: "typescript",
+	command: ["typescript-language-server", "--stdio"],
+	extensions: [".ts"],
+	priority: 1,
+};
+
+/** Simulates a stop that lingers (production stops reach ~21s), which is the behavior under test. */
+const SLOW_STOP_MS = 50;
+
+interface RecordingClientOptions {
+	readonly stopDelayMs: number;
+	readonly initializeError?: Error;
+	readonly alive: boolean;
+}
+
+class RecordingFakeClient {
+	alive: boolean;
+	stopCallCount = 0;
+
+	constructor(
+		readonly root: string,
+		private readonly log: EventLog,
+		private readonly options: RecordingClientOptions,
+	) {
+		this.alive = options.alive;
+	}
+
+	async start(): Promise<void> {
+		this.log.push(`spawn:${this.root}`);
+	}
+
+	async initialize(): Promise<void> {
+		if (this.options.initializeError !== undefined) {
+			throw this.options.initializeError;
+		}
+	}
+
+	isAlive(): boolean {
+		return this.alive;
+	}
+
+	command(): string[] {
+		return [...SERVER.command];
+	}
+
+	async stop(): Promise<void> {
+		this.stopCallCount += 1;
+		this.log.push(`stop-start:${this.root}`);
+		await delay(this.options.stopDelayMs);
+		this.alive = false;
+		this.log.push(`stop-end:${this.root}`);
+	}
+}
+
+class EventLog {
+	readonly entries: string[] = [];
+	private waiters: Array<{ readonly event: string; readonly resolve: () => void }> = [];
+
+	push(event: string): void {
+		this.entries.push(event);
+		const due = this.waiters.filter((waiter) => waiter.event === event);
+		if (due.length === 0) return;
+		this.waiters = this.waiters.filter((waiter) => waiter.event !== event);
+		for (const waiter of due) waiter.resolve();
+	}
+
+	waitFor(event: string): Promise<void> {
+		if (this.entries.includes(event)) return Promise.resolve();
+		return new Promise<void>((resolve) => {
+			this.waiters.push({ event, resolve });
+		});
+	}
+}
+
+function delay(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+interface HarnessOptions {
+	readonly maxResidentClients?: number;
+	readonly stopDelayMs?: number;
+	/** Leading generations whose initialize() rejects; later generations start cleanly. */
+	readonly initializeFailures?: number;
+	/** Generations at or above this index report alive; earlier ones emulate a crash-looping server. */
+	readonly aliveFromGeneration?: number;
+}
+
+function managerHarness(options: HarnessOptions = {}): {
+	readonly manager: LspManager;
+	readonly clients: RecordingFakeClient[];
+	readonly log: EventLog;
+	readonly clock: { value: number };
+} {
+	const clients: RecordingFakeClient[] = [];
+	const log = new EventLog();
+	const clock = { value: 1_000 };
+	const generations = new Map<string, number>();
+	const aliveFrom = options.aliveFromGeneration ?? 1;
+	const stopDelayMs = options.stopDelayMs ?? 0;
+	const initializeFailures = options.initializeFailures ?? 0;
+	const manager = new LspManager({
+		maxResidentClients: options.maxResidentClients ?? 6,
+		reaperIntervalMs: 60_000,
+		idleTimeoutMs: 60_000_000,
+		now: () => clock.value,
+		clientFactory: (root) => {
+			const generation = (generations.get(root) ?? 0) + 1;
+			generations.set(root, generation);
+			const client = new RecordingFakeClient(root, log, {
+				stopDelayMs,
+				alive: generation >= aliveFrom,
+				...(generation <= initializeFailures ? { initializeError: new Error("initialize boom") } : {}),
+			});
+			clients.push(client);
+			return client as unknown as LspClient;
+		},
+	});
+	return { manager, clients, log, clock };
+}
+
+describe("LspManager pending-stop tombstones", () => {
+	it("#given a slow-stopping client evicted at the resident cap #when the evicted root is re-acquired while the stop is pending #then the replacement spawns only after the old client stopped", async () => {
+		// given
+		const { manager, log } = managerHarness({ maxResidentClients: 1, stopDelayMs: SLOW_STOP_MS });
+		try {
+			await manager.getClient("/root-a", SERVER);
+			manager.releaseClient("/root-a", SERVER.id);
+
+			// when: admitting root-b synchronously evicts idle root-a (void stop), and root-a is
+			// re-acquired in the same window while the evicted client's stop is still pending.
+			const rootBPromise = manager.getClient("/root-b", SERVER);
+			const rootAPromise = manager.getClient("/root-a", SERVER);
+			await Promise.all([rootBPromise, rootAPromise]);
+			manager.releaseClient("/root-b", SERVER.id);
+			manager.releaseClient("/root-a", SERVER.id);
+
+			// then
+			expect(log.entries.filter((event) => event.endsWith("/root-a"))).toEqual([
+				"spawn:/root-a",
+				"stop-start:/root-a",
+				"stop-end:/root-a",
+				"spawn:/root-a",
+			]);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given an invalidated client whose stop is still pending #when the same root is re-acquired #then the replacement spawns only after the invalidated client stopped", async () => {
+		// given
+		const { manager, log } = managerHarness({ stopDelayMs: SLOW_STOP_MS });
+		try {
+			await manager.getClient("/root-a", SERVER);
+			manager.releaseClient("/root-a", SERVER.id);
+
+			// when
+			manager.invalidateClient("/root-a", SERVER.id);
+			await manager.getClient("/root-a", SERVER);
+
+			// then
+			expect(log.entries).toEqual([
+				"spawn:/root-a",
+				"stop-start:/root-a",
+				"stop-end:/root-a",
+				"spawn:/root-a",
+			]);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given a client whose initialization failed while its stop is pending #when another getClient races the stop #then the replacement spawns only after the failed client stopped", async () => {
+		// given
+		const { manager, log } = managerHarness({
+			stopDelayMs: SLOW_STOP_MS,
+			initializeFailures: 1,
+		});
+		try {
+			const failing = manager.getClient("/root-fail", SERVER);
+
+			// when: the second acquisition starts once the first one's stop is provably in flight.
+			await log.waitFor("stop-start:/root-fail");
+			const racing = manager.getClient("/root-fail", SERVER);
+			await expect(failing).rejects.toThrow("initialize boom");
+			await racing;
+			manager.releaseClient("/root-fail", SERVER.id);
+
+			// then
+			expect(log.entries).toEqual([
+				"spawn:/root-fail",
+				"stop-start:/root-fail",
+				"stop-end:/root-fail",
+				"spawn:/root-fail",
+			]);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+});
+
+describe("LspManager dead-client respawn budget", () => {
+	it("#given a crash-looping client that is dead on every acquisition #when getClient is called repeatedly #then respawn attempts stay within the retry budget", async () => {
+		// given
+		const { manager, clients } = managerHarness({ aliveFromGeneration: Number.POSITIVE_INFINITY });
+		try {
+			// when
+			for (let attempt = 0; attempt < 8; attempt += 1) {
+				await manager
+					.getClient("/root-crash", SERVER)
+					.then(
+						() => manager.releaseClient("/root-crash", SERVER.id),
+						() => undefined,
+					);
+			}
+
+			// then: one initial generation plus at most two budgeted respawns.
+			expect(clients.length).toBeLessThanOrEqual(3);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given the respawn budget is exhausted #when getClient is called again #then it rejects with a budget error instead of respawning", async () => {
+		// given
+		const { manager } = managerHarness({ aliveFromGeneration: Number.POSITIVE_INFINITY });
+		try {
+			await expect(manager.getClient("/root-crash", SERVER)).rejects.toThrow(/respawn budget/);
+
+			// when / then
+			await expect(manager.getClient("/root-crash", SERVER)).rejects.toThrow(/respawn budget/);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given the budget was exhausted but the cooldown elapsed and the server recovered #when getClient is called #then it spawns again and resets the budget on a healthy generation", async () => {
+		// given: generations one and two crash, the third is healthy.
+		const { manager, clients, clock } = managerHarness({ aliveFromGeneration: 3 });
+		try {
+			await expect(manager.getClient("/root-crash", SERVER)).rejects.toThrow(/respawn budget/);
+
+			// when: cooldown elapses (60s default) and the server stays alive again.
+			clock.value += 60_001;
+			const recovered = await manager.getClient("/root-crash", SERVER);
+			manager.releaseClient("/root-crash", SERVER.id);
+
+			// then
+			expect(clients.length).toBe(3);
+			await expect(manager.getClient("/root-crash", SERVER)).resolves.toBe(recovered);
+			manager.releaseClient("/root-crash", SERVER.id);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+});

package/packages/lsp-core/src/lsp/manager.ts

@@ -1,6 +1,14 @@
 import { reportBestEffortCleanupError } from "./cleanup-errors.js";
 import { LspClient } from "./client.js";
-import { IDLE_TIMEOUT_MS, INIT_TIMEOUT_MS, MAX_RESIDENT_CLIENTS, REAPER_INTERVAL_MS } from "./constants.js";
+import {
+	CLIENT_RESPAWN_COOLDOWN_MS,
+	CLIENT_RESPAWN_RETRY_LIMIT,
+	IDLE_TIMEOUT_MS,
+	INIT_TIMEOUT_MS,
+	MAX_RESIDENT_CLIENTS,
+	REAPER_INTERVAL_MS,
+} from "./constants.js";
+import { LspClientRespawnBudgetExceededError } from "./errors.js";
 import { installProcessSignalCleanup } from "./process-signal-cleanup.js";
 import type { ResolvedServer } from "./types.js";
 
@@ -14,6 +22,11 @@ interface ManagedClient {
 	initializingSince: number | null;
 }
 
+interface RespawnBudget {
+	deadGenerations: number;
+	exhaustedAt: number | null;
+}
+
 export interface ClientSnapshot {
 	root: string;
 	serverId: string;
@@ -75,6 +88,9 @@ function awaitWithSignal<T>(promise: Promise<T>, signal: AbortSignal | undefined
 
 export class LspManager {
 	private readonly clients = new Map<string, ManagedClient>();
+	/** In-flight stops per key; getClient awaits these instead of spawning a duplicate client. */
+	private readonly pendingStops = new Map<string, Promise<void>>();
+	private readonly respawnBudgets = new Map<string, RespawnBudget>();
 	private reaperHandle: NodeJS.Timeout | null = null;
 	private signalDisposer: (() => void) | null = null;
 	private disposed = false;
@@ -112,6 +128,50 @@ export class LspManager {
 		return `${root}::${serverId}`;
 	}
 
+	/**
+	 * Deletes-then-stops with a tombstone: the pending stop is recorded so a concurrent getClient
+	 * for the same key awaits it instead of spawning a duplicate client while the old one lingers
+	 * (production stops reach ~21s). The tombstone removes itself once the stop settles.
+	 */
+	private tombstoneStop(key: string, client: LspClient): Promise<void> {
+		const stop = stopClientBestEffort(client);
+		this.pendingStops.set(key, stop);
+		void stop.finally(() => {
+			if (this.pendingStops.get(key) === stop) {
+				this.pendingStops.delete(key);
+			}
+		});
+		return stop;
+	}
+
+	private recordDeadGeneration(key: string): void {
+		let budget = this.respawnBudgets.get(key);
+		if (budget === undefined) {
+			budget = { deadGenerations: 0, exhaustedAt: null };
+			this.respawnBudgets.set(key, budget);
+		}
+		budget.deadGenerations += 1;
+	}
+
+	private markHealthyGeneration(key: string): void {
+		this.respawnBudgets.delete(key);
+	}
+
+	/** Throws while the respawn budget is spent and the cooldown has not elapsed. */
+	private ensureRespawnAllowed(key: string, root: string, serverId: string): void {
+		const budget = this.respawnBudgets.get(key);
+		if (budget === undefined || budget.deadGenerations < CLIENT_RESPAWN_RETRY_LIMIT) return;
+		if (budget.exhaustedAt === null) {
+			budget.exhaustedAt = this.now();
+			throw new LspClientRespawnBudgetExceededError(serverId, root, CLIENT_RESPAWN_RETRY_LIMIT);
+		}
+		if (this.now() - budget.exhaustedAt < CLIENT_RESPAWN_COOLDOWN_MS) {
+			throw new LspClientRespawnBudgetExceededError(serverId, root, CLIENT_RESPAWN_RETRY_LIMIT);
+		}
+		budget.deadGenerations = 0;
+		budget.exhaustedAt = null;
+	}
+
 	private reapStale(): void {
 		const t = this.now();
 		for (const [key, managed] of this.clients) {
@@ -120,8 +180,8 @@ export class LspManager {
 				managed.initializingSince !== null &&
 				t - managed.initializingSince > this.initTimeoutMs
 			) {
-				void stopClientBestEffort(managed.client);
 				this.clients.delete(key);
+				void this.tombstoneStop(key, managed.client);
 				continue;
 			}
 
@@ -131,8 +191,8 @@ export class LspManager {
 				managed.pendingWaiters === 0 &&
 				t - managed.lastUsedAt > this.idleTimeoutMs
 			) {
-				void stopClientBestEffort(managed.client);
 				this.clients.delete(key);
+				void this.tombstoneStop(key, managed.client);
 			}
 		}
 	}
@@ -148,7 +208,7 @@ export class LspManager {
 			const victim = this.leastRecentlyUsedIdleClient();
 			if (!victim) return;
 			this.clients.delete(victim.key);
-			void stopClientBestEffort(victim.managed.client);
+			void this.tombstoneStop(victim.key, victim.managed.client);
 		}
 	}
 
@@ -171,7 +231,7 @@ export class LspManager {
 			this.clients.get(key) === managed
 		) {
 			this.clients.delete(key);
-			await stopClientBestEffort(managed.client);
+			await this.tombstoneStop(key, managed.client);
 		}
 	}
 
@@ -182,6 +242,16 @@ export class LspManager {
 		signal?.throwIfAborted();
 
 		const key = this.getKey(root, server.id);
+		for (;;) {
+			const pendingStop = this.pendingStops.get(key);
+			if (pendingStop === undefined) break;
+			await awaitWithSignal(pendingStop, signal);
+			signal?.throwIfAborted();
+		}
+		if (this.disposed) {
+			throw new Error("LspManager has been disposed");
+		}
+
 		let managed = this.clients.get(key);
 
 		if (managed) {
@@ -191,8 +261,8 @@ export class LspManager {
 				managed.initializingSince !== null &&
 				t - managed.initializingSince > this.initTimeoutMs
 			) {
-				await stopClientBestEffort(managed.client);
 				this.clients.delete(key);
+				await this.tombstoneStop(key, managed.client);
 				managed = undefined;
 			}
 		}
@@ -216,17 +286,22 @@ export class LspManager {
 			}
 
 			if (!managed.client.isAlive()) {
-				await stopClientBestEffort(managed.client);
-				this.clients.delete(key);
+				this.recordDeadGeneration(key);
+				if (this.clients.get(key) === managed) {
+					this.clients.delete(key);
+				}
+				await this.tombstoneStop(key, managed.client);
 				return this.getClient(root, server, signal);
 			}
 
+			this.markHealthyGeneration(key);
 			managed.refCount++;
 			managed.lastUsedAt = this.now();
 			return managed.client;
 		}
 
 		this.evictForAdmission();
+		this.ensureRespawnAllowed(key, root, server.id);
 
 		const client = this.clientFactory(root, server);
 		const initStartedAt = this.now();
@@ -253,7 +328,7 @@ export class LspManager {
 			if (this.clients.get(key) === newManaged) {
 				this.clients.delete(key);
 			}
-			await stopClientBestEffort(client);
+			await this.tombstoneStop(key, client);
 			throw err;
 		}
 
@@ -267,6 +342,16 @@ export class LspManager {
 			signal.throwIfAborted();
 		}
 
+		if (!client.isAlive()) {
+			this.recordDeadGeneration(key);
+			if (this.clients.get(key) === newManaged) {
+				this.clients.delete(key);
+			}
+			await this.tombstoneStop(key, client);
+			return this.getClient(root, server, signal);
+		}
+
+		this.markHealthyGeneration(key);
 		newManaged.refCount++;
 		newManaged.lastUsedAt = this.now();
 		return client;
@@ -287,15 +372,20 @@ export class LspManager {
 		if (!managed) return;
 		if (client && managed.client !== client) return;
 		this.clients.delete(key);
-		void stopClientBestEffort(managed.client);
+		void this.tombstoneStop(key, managed.client);
 	}
 
 	warmupClient(root: string, server: ResolvedServer): void {
 		if (this.disposed) return;
 		const key = this.getKey(root, server.id);
-		if (this.clients.has(key)) return;
+		if (this.clients.has(key) || this.pendingStops.has(key)) return;
 
 		this.evictForAdmission();
+		try {
+			this.ensureRespawnAllowed(key, root, server.id);
+		} catch {
+			return;
+		}
 
 		const client = this.clientFactory(root, server);
 		const initStartedAt = this.now();
@@ -326,7 +416,7 @@ export class LspManager {
 				if (this.clients.get(key) === managed) {
 					this.clients.delete(key);
 				}
-				void stopClientBestEffort(client);
+				void this.tombstoneStop(key, client);
 			},
 		);
 	}
@@ -379,8 +469,11 @@ export class LspManager {
 		for (const managed of this.clients.values()) {
 			stopPromises.push(stopClientBestEffort(managed.client));
 		}
+		const tombstonedStops = [...this.pendingStops.values()];
 		this.clients.clear();
-		await Promise.allSettled(stopPromises);
+		this.respawnBudgets.clear();
+		await Promise.allSettled([...stopPromises, ...tombstonedStops]);
+		this.pendingStops.clear();
 	}
 }
 

package/packages/lsp-core/src/lsp/workspace-markers.ts

@@ -1 +1,18 @@
-export const WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"] as const;
+/** Repository marker: an ancestor containing this always wins over intermediate package markers. */
+export const GIT_WORKSPACE_MARKER = ".git" as const;
+
+/**
+ * Package/project markers. On their own they resolve to the NEAREST marked directory, but inside a
+ * request cwd they are only a fallback: a `.git` ancestor further up collapses nested package roots
+ * (one client per repository instead of one per monorepo package).
+ */
+export const PROJECT_WORKSPACE_MARKERS = [
+	"package.json",
+	"pyproject.toml",
+	"Cargo.toml",
+	"go.mod",
+	"pom.xml",
+	"build.gradle",
+] as const;
+
+export const WORKSPACE_MARKERS = [GIT_WORKSPACE_MARKER, ...PROJECT_WORKSPACE_MARKERS] as const;

package/packages/lsp-core/src/mcp.ts

@@ -71,6 +71,9 @@ export async function runMcpStdioServer(
 	await runJsonRpcStdioServer({
 		input,
 		output,
+		// Idle stays disabled: hosts of this CLI (legacy opencode configs and
+		// standalone lsp-tools-mcp users) have no evidenced respawn for an exited
+		// stdio server; opencode in particular marks it failed without retry.
 		idleTimeoutMs: 0,
 		parentWatchdog: options.parentWatchdog ?? {},
 		handler: (request) => runWithRequestContext(requestContext, () => handleLspMcpRequest(request)),