lazycodex-ai 5.1.48 → 5.1.54

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-max-clients.test.ts

@@ -0,0 +1,151 @@
+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,
+};
+
+class FakeLspClient {
+	alive = true;
+	stopCallCount = 0;
+
+	constructor(readonly root: string) {}
+
+	async start(): Promise<void> {}
+
+	async initialize(): Promise<void> {}
+
+	isAlive(): boolean {
+		return this.alive;
+	}
+
+	command(): string[] {
+		return [...SERVER.command];
+	}
+
+	async stop(): Promise<void> {
+		this.stopCallCount += 1;
+		this.alive = false;
+	}
+}
+
+function managerWithFakes(maxResidentClients: number): {
+	readonly manager: LspManager;
+	readonly clients: Map<string, FakeLspClient>;
+	readonly clock: { value: number };
+} {
+	const clients = new Map<string, FakeLspClient>();
+	const clock = { value: 1_000 };
+	const manager = new LspManager({
+		maxResidentClients,
+		reaperIntervalMs: 60_000,
+		idleTimeoutMs: 60_000_000,
+		now: () => clock.value,
+		clientFactory: (root) => {
+			const client = new FakeLspClient(root);
+			clients.set(root, client);
+			return client as unknown as LspClient;
+		},
+	});
+	return { manager, clients, clock };
+}
+
+describe("LspManager resident client cap", () => {
+	it("#given a cap of two idle clients #when a third client is admitted #then the least recently used one is stopped and evicted", async () => {
+		// given
+		const { manager, clients, clock } = managerWithFakes(2);
+		try {
+			await manager.getClient("/root-a", SERVER);
+			manager.releaseClient("/root-a", SERVER.id);
+			clock.value += 10;
+			await manager.getClient("/root-b", SERVER);
+			manager.releaseClient("/root-b", SERVER.id);
+			clock.value += 10;
+
+			// when
+			await manager.getClient("/root-c", SERVER);
+			manager.releaseClient("/root-c", SERVER.id);
+
+			// then
+			expect(manager.clientCount()).toBe(2);
+			expect(manager.hasClient("/root-a", SERVER.id)).toBe(false);
+			expect(manager.hasClient("/root-b", SERVER.id)).toBe(true);
+			expect(manager.hasClient("/root-c", SERVER.id)).toBe(true);
+			expect(clients.get("/root-a")?.stopCallCount).toBe(1);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given the least recently used client is mid-request #when a new client is admitted #then the busy client survives and an idle one is evicted", async () => {
+		// given
+		const { manager, clients, clock } = managerWithFakes(2);
+		try {
+			await manager.getClient("/root-busy", SERVER);
+			clock.value += 10;
+			await manager.getClient("/root-idle", SERVER);
+			manager.releaseClient("/root-idle", SERVER.id);
+			clock.value += 10;
+
+			// when
+			await manager.getClient("/root-new", SERVER);
+			manager.releaseClient("/root-new", SERVER.id);
+
+			// then
+			expect(manager.hasClient("/root-busy", SERVER.id)).toBe(true);
+			expect(manager.hasClient("/root-idle", SERVER.id)).toBe(false);
+			expect(clients.get("/root-busy")?.stopCallCount).toBe(0);
+			expect(clients.get("/root-idle")?.stopCallCount).toBe(1);
+		} finally {
+			manager.releaseClient("/root-busy", SERVER.id);
+			await manager.stopAll();
+		}
+	});
+
+	it("#given every resident client is busy #when a new client is admitted #then nothing is evicted and the cap is exceeded rather than breaking a live request", async () => {
+		// given
+		const { manager, clients } = managerWithFakes(1);
+		try {
+			await manager.getClient("/root-busy", SERVER);
+
+			// when
+			await manager.getClient("/root-second", SERVER);
+
+			// then
+			expect(manager.clientCount()).toBe(2);
+			expect(clients.get("/root-busy")?.stopCallCount).toBe(0);
+		} finally {
+			manager.releaseClient("/root-busy", SERVER.id);
+			manager.releaseClient("/root-second", SERVER.id);
+			await manager.stopAll();
+		}
+	});
+
+	it("#given warmup requests beyond the cap #when a warm client is admitted #then the idle least recently used client is evicted too", async () => {
+		// given
+		const { manager, clients, clock } = managerWithFakes(1);
+		try {
+			await manager.getClient("/root-first", SERVER);
+			manager.releaseClient("/root-first", SERVER.id);
+			clock.value += 10;
+
+			// when
+			manager.warmupClient("/root-warm", SERVER);
+			await Promise.resolve();
+			await Promise.resolve();
+
+			// then
+			expect(manager.hasClient("/root-first", SERVER.id)).toBe(false);
+			expect(clients.get("/root-first")?.stopCallCount).toBe(1);
+			expect(manager.hasClient("/root-warm", SERVER.id)).toBe(true);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+});