lazycodex-ai 5.1.48 → 5.1.54

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

@@ -0,0 +1,89 @@
+import type { ServerLookupResult } from "./types.js";
+
+export type FailedServerLookupResult = Exclude<ServerLookupResult, { status: "found" }>;
+
+export class LspConnectionClosedError extends Error {
+	override readonly name = "LspConnectionClosedError";
+
+	constructor(
+		readonly serverId: string,
+		readonly root: string,
+		message?: string,
+	) {
+		super(message ?? `LSP connection closed for ${serverId} at ${root}`);
+	}
+}
+
+export class LspProcessExitedError extends Error {
+	override readonly name = "LspProcessExitedError";
+
+	constructor(
+		readonly serverId: string,
+		readonly root: string,
+		readonly exitCode: number | null,
+		readonly stderrTail?: string,
+	) {
+		const stderrSuffix = stderrTail ? `\nstderr tail: ${stderrTail}` : "";
+		super(`LSP server ${serverId} at ${root} exited with code ${exitCode ?? "null"}${stderrSuffix}`);
+	}
+}
+
+export class LspRequestTimeoutError extends Error {
+	override readonly name = "LspRequestTimeoutError";
+
+	constructor(
+		readonly method: string,
+		readonly stderrTail?: string,
+	) {
+		const stderrSuffix = stderrTail ? `\nrecent stderr: ${stderrTail}` : "";
+		super(`LSP request timeout (method: ${method})${stderrSuffix}`);
+	}
+}
+
+export class LspInvalidPathError extends Error {
+	override readonly name = "LspInvalidPathError";
+}
+
+export class LspServerLookupError extends Error {
+	override readonly name = "LspServerLookupError";
+
+	constructor(
+		message: string,
+		readonly lookup?: FailedServerLookupResult,
+	) {
+		super(message);
+	}
+}
+
+export class LspServerInitializingError extends Error {
+	override readonly name = "LspServerInitializingError";
+
+	constructor(readonly originalError: LspRequestTimeoutError) {
+		super(
+			`LSP server is still initializing. Please retry in a few seconds. Original error: ${originalError.message}`,
+		);
+	}
+}
+
+export class LspProcessSpawnError extends Error {
+	override readonly name = "LspProcessSpawnError";
+}
+
+export class LspClientRespawnBudgetExceededError extends Error {
+	override readonly name = "LspClientRespawnBudgetExceededError";
+
+	constructor(
+		readonly serverId: string,
+		readonly root: string,
+		readonly retryLimit: number,
+	) {
+		super(
+			`LSP server ${serverId} at ${root} failed to stay alive; respawn budget exhausted ` +
+				`(${retryLimit} consecutive dead generations). Retrying after the cooldown may succeed.`,
+		);
+	}
+}
+
+export function isLspDeadConnectionError(err: unknown): err is LspConnectionClosedError | LspProcessExitedError {
+	return err instanceof LspConnectionClosedError || err instanceof LspProcessExitedError;
+}

package/packages/lsp-core/src/lsp/fake-bun-test-support.ts

@@ -0,0 +1,102 @@
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const createdDirs: string[] = [];
+
+function createTempDir(prefix: string): string {
+	const dir = mkdtempSync(join(tmpdir(), prefix));
+	createdDirs.push(dir);
+	return dir;
+}
+
+export function removeFakeBunFixtures(): void {
+	for (const dir of createdDirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+}
+
+export interface FakeBunBehavior {
+	readonly commands: readonly ("check" | "lint" | "format")[];
+	readonly checkStdout?: string;
+	readonly checkExitCode?: number;
+	readonly lintStdout?: string;
+	readonly lintExitCode?: number;
+	readonly formatWrites?: boolean;
+	readonly hangHelpUntil?: string;
+	readonly wrapperForks?: boolean;
+}
+
+export interface FakeBunCall {
+	readonly args: readonly string[];
+	readonly cwd: string;
+	readonly cwdEntries: readonly string[];
+}
+
+export interface FakeBun {
+	readonly path: string;
+	calls(): FakeBunCall[];
+	upgrade(behavior: FakeBunBehavior): void;
+}
+
+export function createFakeBun(behavior: FakeBunBehavior): FakeBun {
+	const dir = createTempDir("omo-fake-bun-");
+	const logPath = join(dir, "calls.jsonl");
+	const binDir = join(dir, "bin");
+	mkdirSync(binDir);
+	const path = process.platform === "win32" ? join(binDir, "bun.cmd") : join(binDir, "bun");
+	let version = 0;
+	const install = (next: FakeBunBehavior) => {
+		version += 1;
+		const scriptPath = join(dir, `fake-bun-${version}.mjs`);
+		writeFakeBunScript(scriptPath, logPath, next);
+		if (process.platform === "win32") {
+			writeFileSync(path, `@"${process.execPath}" "${scriptPath}" %*\r\n`);
+		} else {
+			const launch = `"${process.execPath}" "${scriptPath}" "$@"`;
+			writeFileSync(path, next.wrapperForks ? `#!/bin/sh\n${launch}\n` : `#!/bin/sh\nexec ${launch}\n`);
+			chmodSync(path, 0o755);
+		}
+	};
+	install(behavior);
+	return {
+		path,
+		upgrade: install,
+		calls: () =>
+			existsSync(logPath)
+				? readFileSync(logPath, "utf8")
+						.split("\n")
+						.filter((line) => line.length > 0)
+						.map((line): FakeBunCall => JSON.parse(line))
+				: [],
+	};
+}
+
+function writeFakeBunScript(scriptPath: string, logPath: string, behavior: FakeBunBehavior): void {
+	writeFileSync(
+		scriptPath,
+		[
+			'import { appendFileSync, existsSync, readdirSync, writeFileSync } from "node:fs";',
+			`const behavior = ${JSON.stringify(behavior)};`,
+			'if (behavior.hangHelpUntil && process.argv.includes("--help") && !existsSync(behavior.hangHelpUntil)) await new Promise((r) => setTimeout(r, 60_000));',
+			"const args = process.argv.slice(2);",
+			`appendFileSync(${JSON.stringify(logPath)}, JSON.stringify({ args, cwd: process.cwd(), cwdEntries: readdirSync(process.cwd()) }) + "\\n");`,
+			"const [command] = args;",
+			"if (!behavior.commands.includes(command)) process.exit(1);",
+			'if (args.includes("--help")) process.exit(0);',
+			'if (command === "check") { process.stdout.write(behavior.checkStdout ?? ""); process.exit(behavior.checkExitCode ?? 0); }',
+			'if (command === "lint") { process.stdout.write(behavior.lintStdout ?? "[]"); process.exit(behavior.lintExitCode ?? 0); }',
+			'if (command === "format" && behavior.formatWrites && args.includes("--write")) writeFileSync(args[args.length - 1], "const a = 1;\\n");',
+			"process.exit(0);",
+		].join("\n"),
+	);
+}
+
+export function createProject(files: Record<string, string>, options: { readonly git?: boolean } = {}): string {
+	const root = createTempDir("omo-bun-project-");
+	if (options.git !== false) mkdirSync(join(root, ".git"));
+	for (const [relativePath, content] of Object.entries(files)) {
+		const target = join(root, relativePath);
+		mkdirSync(join(target, ".."), { recursive: true });
+		writeFileSync(target, content);
+	}
+	return root;
+}

package/packages/lsp-core/src/lsp/fixtures/diagnostics-freshness-contract-probe.ts

@@ -0,0 +1,283 @@
+import { writeFileSync } from "node:fs";
+
+import {
+	createWorkspaceEditTestHarness,
+	diagnostic,
+	readEvents,
+	waitForEventCount,
+} from "../workspace-apply-edit-test-support.js";
+
+class DiagnosticsFreshnessContractProbeError extends Error {
+	override readonly name = "DiagnosticsFreshnessContractProbeError";
+}
+
+function requireProbe(condition: boolean, message: string): asserts condition {
+	if (!condition) throw new DiagnosticsFreshnessContractProbeError(message);
+}
+
+const outputPath = process.argv[2];
+if (!outputPath) throw new DiagnosticsFreshnessContractProbeError("output path is required");
+
+const harness = createWorkspaceEditTestHarness();
+
+try {
+	const exactCurrent = await harness.makeClient(
+		{
+			publishDiagnostics: [
+				{
+					trigger: "didOpen",
+					version: 1,
+					diagnostics: [diagnostic("exact-current")],
+				},
+			],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+	);
+	const [exactFirst, exactSecond] = await Promise.all([
+		exactCurrent.client.diagnostics(exactCurrent.source),
+		exactCurrent.client.diagnostics(exactCurrent.source),
+	]);
+	const exactDidOpenCount = readEvents(exactCurrent.events).filter(
+		(event) => event.type === "clientNotification" && event.method === "textDocument/didOpen",
+	).length;
+	const exactCurrentEvidence = {
+		outcome: "exact-current",
+		items: exactFirst.items.map((entry) => entry.message),
+		concurrentItems: exactSecond.items.map((entry) => entry.message),
+		didOpenCount: exactDidOpenCount,
+		ok:
+			exactDidOpenCount === 1
+			&& JSON.stringify(exactFirst.items) === JSON.stringify([diagnostic("exact-current")])
+			&& JSON.stringify(exactSecond.items) === JSON.stringify([diagnostic("exact-current")]),
+	};
+	requireProbe(exactCurrentEvidence.ok, "exact-current diagnostics did not resolve immediately with a single didOpen");
+
+	const postGenerationVersionless = await harness.makeClient(
+		{
+			publishDiagnostics: [
+				{
+					trigger: "didChange",
+					diagnostics: [diagnostic("post-generation-versionless")],
+				},
+			],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 80, versionlessPublishQuiescenceMs: 20 },
+	);
+	await postGenerationVersionless.client.openFile(postGenerationVersionless.source);
+	await waitForEventCount(
+		postGenerationVersionless.events,
+		(event) => event.type === "serverNotification" && event.method === "textDocument/publishDiagnostics",
+		1,
+	);
+	writeFileSync(postGenerationVersionless.source, "const post_generation = 1;\n", "utf-8");
+	await postGenerationVersionless.client.openFile(postGenerationVersionless.source);
+	const versionlessStartedAt = Date.now();
+	const versionlessResult = await postGenerationVersionless.client.diagnostics(postGenerationVersionless.source);
+	const versionlessElapsedMs = Date.now() - versionlessStartedAt;
+	const postGenerationVersionlessEvidence = {
+		outcome: "post-generation-versionless",
+		items: versionlessResult.items.map((entry) => entry.message),
+		elapsedMs: versionlessElapsedMs,
+		ok:
+			JSON.stringify(versionlessResult.items) === JSON.stringify([diagnostic("post-generation-versionless")])
+			&& versionlessElapsedMs >= 15,
+	};
+	requireProbe(
+		postGenerationVersionlessEvidence.ok,
+		"post-generation versionless diagnostics did not wait for quiescence before resolving",
+	);
+
+	const stale = await harness.makeClient(
+		{
+			publishDiagnostics: [
+				{
+					trigger: "didChange",
+					version: 1,
+					diagnostics: [diagnostic("stale")],
+				},
+			],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 30, versionlessPublishQuiescenceMs: 5 },
+	);
+	await stale.client.openFile(stale.source);
+	writeFileSync(stale.source, "const stale = 1;\n", "utf-8");
+	await stale.client.openFile(stale.source);
+	const staleResult = await stale.client.diagnostics(stale.source);
+	const staleEvidence = {
+		outcome: "stale",
+		items: staleResult.items.map((entry) => entry.message),
+		transientError: staleResult.transientError ?? null,
+		ok: staleResult.items.length === 0 && staleResult.transientError?.kind === "freshness_timeout",
+	};
+	requireProbe(staleEvidence.ok, "stale diagnostics unexpectedly satisfied the current request");
+
+	const future = await harness.makeClient(
+		{
+			publishDiagnostics: [
+				{
+					trigger: "didChange",
+					version: 3,
+					diagnostics: [diagnostic("future")],
+				},
+			],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 30, versionlessPublishQuiescenceMs: 5 },
+	);
+	await future.client.openFile(future.source);
+	writeFileSync(future.source, "const future = 1;\n", "utf-8");
+	await future.client.openFile(future.source);
+	const futureResult = await future.client.diagnostics(future.source);
+	const futureEvidence = {
+		outcome: "future",
+		items: futureResult.items.map((entry) => entry.message),
+		transientError: futureResult.transientError ?? null,
+		ok: futureResult.items.length === 0 && futureResult.transientError?.kind === "freshness_timeout",
+	};
+	requireProbe(futureEvidence.ok, "future diagnostics unexpectedly satisfied the current request");
+
+	const pullOvertaken = await harness.makeClient(
+		{
+			capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+			diagnosticResponses: [
+				{
+					delayMs: 20,
+					report: { kind: "full", resultId: "v1", items: [diagnostic("pull-stale")] },
+				},
+				{
+					report: { kind: "full", resultId: "v2", items: [diagnostic("pull-fresh")] },
+				},
+			],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 80, versionlessPublishQuiescenceMs: 5 },
+	);
+	await pullOvertaken.client.openFile(pullOvertaken.source);
+	const pendingPull = pullOvertaken.client.diagnostics(pullOvertaken.source);
+	await waitForEventCount(
+		pullOvertaken.events,
+		(event) => event.type === "clientRequest" && event.method === "textDocument/diagnostic",
+		1,
+	);
+	writeFileSync(pullOvertaken.source, "const pull_fresh = 1;\n", "utf-8");
+	await pullOvertaken.client.openFile(pullOvertaken.source);
+	const pullOvertakenResult = await pendingPull;
+	const pullRequestCount = readEvents(pullOvertaken.events).filter(
+		(event) => event.type === "clientRequest" && event.method === "textDocument/diagnostic",
+	).length;
+	const pullOvertakenEvidence = {
+		outcome: "pull-overtaken",
+		items: pullOvertakenResult.items.map((entry) => entry.message),
+		requestCount: pullRequestCount,
+		ok:
+			JSON.stringify(pullOvertakenResult.items) === JSON.stringify([diagnostic("pull-fresh")])
+			&& pullRequestCount === 2,
+	};
+	requireProbe(
+		pullOvertakenEvidence.ok,
+		"pull diagnostics were not invalidated and retried after a local change overtook the in-flight request",
+	);
+
+	const silent = await harness.makeClient({}, { diagnosticsFreshnessTimeoutMs: 35, versionlessPublishQuiescenceMs: 5 });
+	const silentResult = await silent.client.diagnostics(silent.source);
+	const silentEvidence = {
+		outcome: "silent",
+		items: silentResult.items.map((entry) => entry.message),
+		transientError: silentResult.transientError ?? null,
+		ok: silentResult.items.length === 0 && silentResult.transientError === undefined,
+	};
+	requireProbe(silentEvidence.ok, "silent no-pull server that never published did not resolve clean after the freshness window");
+
+	const closedServer = await harness.makeClient(
+		{
+			capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+			diagnosticResponses: [{ action: "close" }],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+	);
+	await closedServer.client.openFile(closedServer.source);
+	let closedServerError = "";
+	try {
+		await closedServer.client.diagnostics(closedServer.source);
+	} catch (error) {
+		closedServerError = error instanceof Error ? error.message : String(error);
+	}
+	const closedServerEvidence = {
+		outcome: "closed-server",
+		error: closedServerError,
+		ok: /exited|closed/i.test(closedServerError),
+	};
+	requireProbe(closedServerEvidence.ok, "closed-server diagnostics failure was not surfaced as a transport error");
+
+	const unsupportedPull = await harness.makeClient(
+		{
+			capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+			publishDiagnostics: [
+				{
+					trigger: "didOpen",
+					version: 1,
+					diagnostics: [diagnostic("push-fallback")],
+				},
+			],
+			diagnosticResponses: [{ error: { code: -32601, message: "Method not found" } }],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+	);
+	const unsupportedPullResult = await unsupportedPull.client.diagnostics(unsupportedPull.source);
+	const unsupportedPullEvidence = {
+		outcome: "unsupported-pull",
+		items: unsupportedPullResult.items.map((entry) => entry.message),
+		ok: JSON.stringify(unsupportedPullResult.items) === JSON.stringify([diagnostic("push-fallback")]),
+	};
+	requireProbe(unsupportedPullEvidence.ok, "explicitly unsupported pull did not fall back to push diagnostics");
+
+	const unchanged = await harness.makeClient(
+		{
+			capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+			diagnosticResponses: [
+				{
+					report: { kind: "full", resultId: "same-version", items: [diagnostic("cached-full")] },
+				},
+				{
+					report: { kind: "unchanged", resultId: "same-version" },
+				},
+			],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+	);
+	await unchanged.client.openFile(unchanged.source);
+	const unchangedFirst = await unchanged.client.diagnostics(unchanged.source);
+	const unchangedSecond = await unchanged.client.diagnostics(unchanged.source);
+	const unchangedEvidence = {
+		outcome: "same-version-unchanged",
+		firstItems: unchangedFirst.items.map((entry) => entry.message),
+		secondItems: unchangedSecond.items.map((entry) => entry.message),
+		ok:
+			JSON.stringify(unchangedFirst.items) === JSON.stringify([diagnostic("cached-full")])
+			&& JSON.stringify(unchangedSecond.items) === JSON.stringify([diagnostic("cached-full")]),
+	};
+	requireProbe(unchangedEvidence.ok, "unchanged pull did not reuse the cached same-version result");
+
+	writeFileSync(
+		outputPath,
+		`${JSON.stringify(
+			{
+				schemaVersion: 1,
+				outcomes: {
+					exactCurrent: exactCurrentEvidence,
+					postGenerationVersionless: postGenerationVersionlessEvidence,
+					stale: staleEvidence,
+					future: futureEvidence,
+					pullOvertaken: pullOvertakenEvidence,
+					silent: silentEvidence,
+					closedServer: closedServerEvidence,
+					unsupportedPull: unsupportedPullEvidence,
+					sameVersionUnchanged: unchangedEvidence,
+				},
+			},
+			null,
+			2,
+		)}\n`,
+		"utf-8",
+	);
+} finally {
+	await harness.cleanup();
+}

package/packages/lsp-core/src/lsp/fixtures/disposed-stdin-epipe-probe.ts

@@ -0,0 +1,28 @@
+// Reproduces the Windows teardown race from #9601 on any OS: the transport
+// disposes its JSON-RPC connection, then the server's stdin pipe fails with
+// EPIPE. Windows reports that failure asynchronously, after dispose removed the
+// connection's listener, so the stream is destroyed with the error here to get
+// the same event order deterministically. The probe exits 0 only when the error
+// was handled; an unhandled 'error' event crashes it with a non-zero exit.
+import { JsonRpcConnection } from "../json-rpc-connection.js";
+import { spawnProcess } from "../process.js";
+
+const server = spawnProcess([process.execPath, "-e", "process.stdin.on('close', () => process.exit(0)).resume()"], {
+	cwd: process.cwd(),
+	env: process.env,
+});
+const connection = new JsonRpcConnection(server.stdout, server.stdin);
+connection.listen();
+connection.dispose();
+
+const stdinClosed = new Promise<void>((resolve) => server.stdin.once("close", () => resolve()));
+const epipe = Object.assign(new Error("EPIPE: broken pipe, write"), { code: "EPIPE", syscall: "write", errno: -4047 });
+if (!("destroy" in server.stdin) || typeof server.stdin.destroy !== "function") {
+	throw new Error("server stdin is not destroyable");
+}
+server.stdin.destroy(epipe);
+await stdinClosed;
+
+server.kill("SIGKILL");
+await server.exited;
+process.stdout.write("PROBE_SURVIVED\n");