lazycodex-ai 5.1.48 → 5.1.54

package/packages/lsp-core/src/lsp/server-resolution-local-binary.test.ts

@@ -0,0 +1,170 @@
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { runWithRequestContext } from "../request-context.js";
+import { formatServerLookupError } from "./client-wrapper.js";
+import { __resetServerBinaryResolutionCacheForTests } from "./server-installation.js";
+import { findServerForExtension } from "./server-resolution.js";
+
+const tempDirectories: string[] = [];
+let previousPath: string | undefined;
+
+function makeTempRoot(prefix: string): string {
+	const root = mkdtempSync(join(tmpdir(), prefix));
+	tempDirectories.push(root);
+	return root;
+}
+
+function writeExecutable(path: string): string {
+	mkdirSync(join(path, ".."), { recursive: true });
+	writeFileSync(path, "#!/bin/sh\nexit 0\n");
+	chmodSync(path, 0o755);
+	return path;
+}
+
+function contextFor(cwd: string) {
+	return {
+		cwd,
+		projectConfigPaths: [join(cwd, ".codex", "lsp-client.json")],
+		userConfigPath: join(cwd, "home-config", "lsp-client.json"),
+		installDecisionsPath: join(cwd, "home-config", "lsp-install-decisions.json"),
+		capabilities: { installDecisionTool: true },
+	} as const;
+}
+
+beforeEach(() => {
+	previousPath = process.env["PATH"];
+	__resetServerBinaryResolutionCacheForTests();
+});
+
+afterEach(() => {
+	if (previousPath === undefined) delete process.env["PATH"];
+	else process.env["PATH"] = previousPath;
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+	__resetServerBinaryResolutionCacheForTests();
+});
+
+describe("findServerForExtension local binary substitution", () => {
+	test("#given a repo-local biome #when looking up a typescript file #then the command spawns the absolute local path", () => {
+		// given
+		const root = makeTempRoot("lsp-resolution-local-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		const binaryPath = writeExecutable(join(root, "node_modules", ".bin", "biome"));
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".ts"));
+
+		// then
+		expect(result.status).toBe("found");
+		if (result.status !== "found") throw new Error("expected a found server");
+		expect(result.server.command[0]).toBe(binaryPath);
+		expect(result.server.command.slice(1)).toEqual(["lsp-proxy", "--stdio"]);
+	});
+
+	test("#given a PATH-only server #when looking up #then the resolved PATH entry is substituted", () => {
+		// given
+		const root = makeTempRoot("lsp-resolution-path-root-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		const pathDir = makeTempRoot("lsp-resolution-path-");
+		const pathBinary = writeExecutable(join(pathDir, "biome"));
+		process.env["PATH"] = pathDir;
+
+		// when
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".ts"));
+
+		// then
+		expect(result.status).toBe("found");
+		if (result.status !== "found") throw new Error("expected a found server");
+		expect(result.server.command[0]).toBe(pathBinary);
+	});
+
+	test("#given no server anywhere #when looking up #then the not_installed result is preserved", () => {
+		// given
+		const root = makeTempRoot("lsp-resolution-missing-");
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".ts"));
+
+		// then
+		expect(result.status).toBe("not_installed");
+		if (result.status !== "not_installed") throw new Error("expected not_installed");
+		expect(result.installHint.length).toBeGreaterThan(0);
+	});
+
+	test("#given an unknown extension #when looking up #then the not_configured result is preserved", () => {
+		// given
+		const root = makeTempRoot("lsp-resolution-unknown-");
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".unknown-ext"));
+
+		// then
+		expect(result.status).toBe("not_configured");
+	});
+});
+
+describe("not-installed message repo-local guidance", () => {
+	test("#given a missing biome #when formatting the message #then the repo-local install is suggested before the global hint", () => {
+		// given: .css is served by biome alone, so the lookup cannot fall through to typescript
+		const root = makeTempRoot("lsp-message-biome-");
+		process.env["PATH"] = join(root, "definitely-empty");
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".css"));
+		if (result.status !== "not_installed") throw new Error("expected not_installed");
+		expect(result.server.id).toBe("biome");
+
+		// when
+		const message = runWithRequestContext(contextFor(root), () => formatServerLookupError(result));
+
+		// then
+		expect(message).toContain("bun add -d @biomejs/biome");
+		expect(message).toContain("npm install -g @biomejs/biome");
+		expect(message.indexOf("bun add -d @biomejs/biome")).toBeLessThan(message.indexOf("npm install -g @biomejs/biome"));
+		expect(message).toContain("ACTION REQUIRED");
+		expect(message).toContain("NOT INSTALLED");
+	});
+
+	test("#given a server with no repo-local route #when formatting the message #then only the global hint is shown", () => {
+		// given
+		const root = makeTempRoot("lsp-message-global-");
+		process.env["PATH"] = join(root, "definitely-empty");
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".rs"));
+		if (result.status !== "not_installed") throw new Error("expected not_installed");
+
+		// when
+		const message = runWithRequestContext(contextFor(root), () => formatServerLookupError(result));
+
+		// then
+		expect(message).toContain("To install, run:");
+		expect(message).not.toContain("THIS repository");
+		expect(message).toContain("ACTION REQUIRED");
+	});
+
+	test("#given a pre-authorized install #when formatting the message #then both install routes stay visible", () => {
+		// given
+		const root = makeTempRoot("lsp-message-allowed-");
+		process.env["PATH"] = join(root, "definitely-empty");
+		const context = contextFor(root);
+		mkdirSync(join(root, "home-config"), { recursive: true });
+		writeFileSync(
+			context.installDecisionsPath,
+			`${JSON.stringify({ biome: { decision: "allowed", decidedAt: new Date().toISOString() } })}\n`,
+		);
+		const result = runWithRequestContext(context, () => findServerForExtension(".css"));
+		if (result.status !== "not_installed") throw new Error("expected not_installed");
+
+		// when
+		const message = runWithRequestContext(context, () => formatServerLookupError(result));
+
+		// then
+		expect(message).toContain("pre-authorized");
+		expect(message).toContain("bun add -d @biomejs/biome");
+		expect(message).toContain("npm install -g @biomejs/biome");
+	});
+});

package/packages/lsp-core/src/lsp/server-resolution.ts

@@ -0,0 +1,125 @@
+import { contextCwd } from "../request-context.js";
+import { getDisabledServerIds, getMergedServers } from "./config-loader.js";
+import { withHostJsRuntime } from "./host-js-runtime.js";
+import { BUILTIN_SERVERS, LSP_INSTALL_HINTS } from "./server-definitions.js";
+import { isServerInstalled, resolveServerBinary } from "./server-installation.js";
+import type { ServerLookupResult } from "./types.js";
+
+/**
+ * Replaces the command name with the absolute binary path so the client spawns the exact
+ * binary that was resolved -- in particular a repo-local one that is absent from PATH.
+ */
+function withResolvedCommand(command: string[], binaryPath: string): string[] {
+	return [binaryPath, ...command.slice(1)];
+}
+
+function usesBuiltinCommand(id: string, command: string[]): boolean {
+	const builtin = BUILTIN_SERVERS[id]?.command;
+	return builtin !== undefined && builtin.length === command.length && builtin.every((part, index) => part === command[index]);
+}
+
+export function findServerForExtension(ext: string): ServerLookupResult {
+	const servers = getMergedServers();
+	const workingDirectory = contextCwd();
+
+	for (const server of servers) {
+		if (!server.extensions.includes(ext)) continue;
+		const binaryPath = resolveServerBinary(server.command, workingDirectory);
+		if (binaryPath !== null) {
+			const resolvedServer = {
+				id: server.id,
+				command: usesBuiltinCommand(server.id, server.command)
+					? withHostJsRuntime(server.id, withResolvedCommand(server.command, binaryPath))
+					: withResolvedCommand(server.command, binaryPath),
+				extensions: server.extensions,
+				priority: server.priority,
+			};
+			if (server.env !== undefined) {
+				return {
+					status: "found",
+					server: {
+						...resolvedServer,
+						env: server.env,
+						...(server.initialization === undefined ? {} : { initialization: server.initialization }),
+					},
+				};
+			}
+			return {
+				status: "found",
+				server: {
+					...resolvedServer,
+					...(server.initialization === undefined ? {} : { initialization: server.initialization }),
+				},
+			};
+		}
+	}
+
+	for (const server of servers) {
+		if (server.extensions.includes(ext)) {
+			const installHint =
+				LSP_INSTALL_HINTS[server.id] ?? `Install '${server.command[0]}' and ensure it's in your PATH`;
+			return {
+				status: "not_installed",
+				server: {
+					id: server.id,
+					command: server.command,
+					extensions: server.extensions,
+				},
+				installHint,
+			};
+		}
+	}
+
+	const availableServers = [...new Set(servers.map((s) => s.id))];
+	return {
+		status: "not_configured",
+		extension: ext,
+		availableServers,
+	};
+}
+
+export interface ServerStatus {
+	id: string;
+	installed: boolean;
+	extensions: string[];
+	disabled: boolean;
+	source: string;
+	priority: number;
+}
+
+export function getAllServers(): ServerStatus[] {
+	const servers = getMergedServers();
+	const disabled = getDisabledServerIds();
+	const workingDirectory = contextCwd();
+
+	const result: ServerStatus[] = [];
+	const seen = new Set<string>();
+
+	for (const server of servers) {
+		if (seen.has(server.id)) continue;
+		result.push({
+			id: server.id,
+			installed: isServerInstalled(server.command, workingDirectory),
+			extensions: server.extensions,
+			disabled: false,
+			source: server.source,
+			priority: server.priority,
+		});
+		seen.add(server.id);
+	}
+
+	for (const id of disabled) {
+		if (seen.has(id)) continue;
+		const builtin = BUILTIN_SERVERS[id];
+		result.push({
+			id,
+			installed: builtin ? isServerInstalled(builtin.command, workingDirectory) : false,
+			extensions: builtin?.extensions ?? [],
+			disabled: true,
+			source: "disabled",
+			priority: 0,
+		});
+	}
+
+	return result;
+}

package/packages/lsp-core/src/lsp/startup-failure.ts

@@ -0,0 +1 @@
+export * from "./utils.js";

package/packages/lsp-core/src/lsp/timer-provider.ts

@@ -0,0 +1,13 @@
+export type TimerHandle = ReturnType<typeof setTimeout>;
+
+export interface TimerProvider {
+	readonly now: () => number;
+	readonly setTimeout: (callback: () => void, delayMs: number) => TimerHandle;
+	readonly clearTimeout: (handle: TimerHandle) => void;
+}
+
+export const realTimerProvider: TimerProvider = {
+	now: () => Date.now(),
+	setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+	clearTimeout: (handle) => clearTimeout(handle),
+};

package/packages/lsp-core/src/lsp/transport-protocol.ts

@@ -0,0 +1,52 @@
+import type { Diagnostic } from "./types.js";
+
+interface ConfigurationItem {
+	readonly section?: string;
+}
+
+interface DiagnosticsParams {
+	readonly uri: string;
+	readonly diagnostics: Diagnostic[];
+	readonly version?: number;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function parseConfigurationItems(params: unknown): ConfigurationItem[] {
+	if (!isRecord(params) || !Array.isArray(params["items"])) return [];
+	const items: ConfigurationItem[] = [];
+	for (const item of params["items"]) {
+		if (!isRecord(item)) continue;
+		const section = item["section"];
+		items.push(section === undefined || typeof section !== "string" ? {} : { section });
+	}
+	return items;
+}
+
+export function parseDiagnosticsParams(params: unknown): DiagnosticsParams | null {
+	if (!isRecord(params) || typeof params["uri"] !== "string") return null;
+	const diagnostics = Array.isArray(params["diagnostics"]) ? params["diagnostics"].filter(isDiagnostic) : [];
+	const version = typeof params["version"] === "number" ? params["version"] : undefined;
+	return { uri: params["uri"], diagnostics, ...(version === undefined ? {} : { version }) };
+}
+
+export function createLspSpawnEnv(
+	_root: string,
+	input: Record<string, string | undefined>,
+): Record<string, string | undefined> {
+	return { ...input };
+}
+
+function isDiagnostic(value: unknown): value is Diagnostic {
+	return isRecord(value) && isRange(value["range"]) && typeof value["message"] === "string";
+}
+
+function isRange(value: unknown): value is Diagnostic["range"] {
+	return isRecord(value) && isPosition(value["start"]) && isPosition(value["end"]);
+}
+
+function isPosition(value: unknown): value is Diagnostic["range"]["start"] {
+	return isRecord(value) && typeof value["line"] === "number" && typeof value["character"] === "number";
+}

package/packages/lsp-core/src/lsp/transport-request-timeout.test.ts

@@ -0,0 +1,73 @@
+import { PassThrough } from "node:stream";
+
+import { describe, expect, it } from "bun:test";
+
+import { ControlledClock } from "./controlled-clock-test-support.js";
+import { LspRequestTimeoutError } from "./errors.js";
+import { JsonRpcConnection } from "./json-rpc-connection.js";
+import { LspClientTransport } from "./transport.js";
+import type { LspClientTimeoutOptions } from "./transport.js";
+import type { ResolvedServer } from "./types.js";
+
+const fakeServer: ResolvedServer = {
+	id: "controlled-clock-fake",
+	command: ["controlled-clock-fake"],
+	extensions: [".ts"],
+	priority: 0,
+};
+
+class WiredTransport extends LspClientTransport {
+	constructor(timeouts: LspClientTimeoutOptions, connection: JsonRpcConnection) {
+		super("/tmp", fakeServer, timeouts);
+		this.connection = connection;
+	}
+
+	request<T>(method: string, params: unknown, options: { timeoutMs?: number }): Promise<T> {
+		return this.sendRequest<T>(method, params, options);
+	}
+}
+
+function encodeMessage(message: Record<string, unknown>): string {
+	const body = JSON.stringify(message);
+	return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+
+function makeWiredTransport(clock: ControlledClock): { transport: WiredTransport; serverToClient: PassThrough } {
+	const serverToClient = new PassThrough();
+	const clientToServer = new PassThrough();
+	const connection = new JsonRpcConnection(serverToClient, clientToServer);
+	connection.listen();
+	return { transport: new WiredTransport({ timerProvider: clock }, connection), serverToClient };
+}
+
+describe("LspClientTransport request timeout via TimerProvider", () => {
+	it("#given a request the server never answers #when the injected clock passes the timeout #then the request rejects with LspRequestTimeoutError", async () => {
+		const clock = new ControlledClock();
+		const { transport } = makeWiredTransport(clock);
+
+		const pending = transport.request("textDocument/diagnostic", { textDocument: { uri: "file:///a.ts" } }, {
+			timeoutMs: 50,
+		});
+		await clock.waitForTimer(50);
+		expect(clock.scheduledDelays.at(-1)).toBe(50);
+		clock.advanceBy(50);
+
+		await expect(pending).rejects.toBeInstanceOf(LspRequestTimeoutError);
+	});
+
+	it("#given a request answered before the deadline #when the injected clock later passes the timeout #then the settled result stands", async () => {
+		const clock = new ControlledClock();
+		const { transport, serverToClient } = makeWiredTransport(clock);
+
+		const pending = transport.request<{ items: unknown[] }>(
+			"textDocument/diagnostic",
+			{ textDocument: { uri: "file:///a.ts" } },
+			{ timeoutMs: 50 },
+		);
+		await clock.waitForTimer(50);
+		serverToClient.write(encodeMessage({ jsonrpc: "2.0", id: 1, result: { items: [] } }));
+
+		await expect(pending).resolves.toEqual({ items: [] });
+		clock.advanceBy(50);
+	});
+});