oh-my-opencode 4.9.2 → 4.11.0

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

@@ -0,0 +1,5 @@
+export function reportBestEffortCleanupError(operation: string, error: unknown): void {
+	if (process.env["CODEX_LSP_DEBUG_CLEANUP"] !== "1") return;
+	const message = error instanceof Error ? error.message : String(error);
+	console.error(`[codex-lsp] ignored ${operation} failure during cleanup: ${message}`);
+}

package/packages/lsp-core/src/lsp/client-wrapper.ts

@@ -0,0 +1,173 @@
+import { existsSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { contextCwd } from "../request-context.js";
+import type { LspClient } from "./client.js";
+import { effectiveExtension } from "./effective-extension.js";
+import {
+	isLspDeadConnectionError,
+	LspInvalidPathError,
+	LspRequestTimeoutError,
+	LspServerInitializingError,
+	LspServerLookupError,
+} from "./errors.js";
+import { getLspManager, type LspManager } from "./manager.js";
+import { loadInstallDecision } from "./server-install-state.js";
+import { findServerForExtension } from "./server-resolution.js";
+import type { ServerLookupResult } from "./types.js";
+
+const WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
+
+export function isDirectoryPath(filePath: string): boolean {
+	try {
+		return statSync(filePath).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+export function findWorkspaceRoot(filePath: string): string {
+	const abs = resolve(contextCwd(), filePath);
+	let dir = abs;
+
+	if (!isDirectoryPath(dir)) {
+		dir = dirname(dir);
+	}
+
+	let prevDir = "";
+	while (dir !== prevDir) {
+		for (const marker of WORKSPACE_MARKERS) {
+			if (existsSync(join(dir, marker))) {
+				return dir;
+			}
+		}
+		prevDir = dir;
+		dir = dirname(dir);
+	}
+
+	return dirname(abs);
+}
+
+export function formatServerLookupError(result: Exclude<ServerLookupResult, { status: "found" }>): string {
+	if (result.status === "not_installed") {
+		return formatNotInstalled(result);
+	}
+
+	return [
+		`No LSP server configured for extension: ${result.extension}`,
+		"",
+		`Available servers: ${result.availableServers.slice(0, 10).join(", ")}${
+			result.availableServers.length > 10 ? "..." : ""
+		}`,
+		"",
+		"Configure a custom server in '.codex/lsp-client.json':",
+		"  {",
+		'    "lsp": {',
+		'      "my-server": {',
+		'        "command": ["my-lsp", "--stdio"],',
+		`        "extensions": ["${result.extension}"]`,
+		"      }",
+		"    }",
+		"  }",
+	].join("\n");
+}
+
+function formatNotInstalled(result: Extract<ServerLookupResult, { status: "not_installed" }>): string {
+	const { server, installHint } = result;
+	const extensions = server.extensions.join(", ");
+	const decision = loadInstallDecision(server.id)?.decision;
+
+	if (decision === "declined") {
+		return `LSP server '${server.id}' (${extensions}) is NOT INSTALLED; user previously declined installation — proceed without LSP.`;
+	}
+
+	const header = [
+		`LSP server '${server.id}' for ${extensions} is NOT INSTALLED.`,
+		"",
+		`Command not found: ${server.command[0]}`,
+		"",
+	];
+
+	if (decision === "allowed") {
+		return [
+			...header,
+			"The user has pre-authorized LSP installation. Run the install command, then retry this tool:",
+			`  ${installHint}`,
+		].join("\n");
+	}
+
+	return [
+		...header,
+		"To install, run:",
+		`  ${installHint}`,
+		"",
+		"ACTION REQUIRED — ASK THE USER whether to install this LSP server.",
+		"- If the user agrees: run the install command above, then retry this tool.",
+		"- If the user declines, OR has NOT explicitly asked for LSP installation:",
+		`    call lsp_install_decision { server_id: "${server.id}", decision: "declined" },`,
+		"    then ignore this message and proceed WITHOUT LSP.",
+	].join("\n");
+}
+
+export interface WithLspClientOptions {
+	signal?: AbortSignal;
+	manager?: LspManager;
+}
+
+const READ_ONLY_RETRY_TOOLS = new Set([
+	"diagnostics",
+	"definition",
+	"references",
+	"documentSymbols",
+	"workspaceSymbols",
+	"prepareRename",
+]);
+
+export async function withLspClient<T>(
+	filePath: string,
+	fn: (client: LspClient, workspaceRoot: string) => Promise<T>,
+	toolName: string,
+	options: WithLspClientOptions = {},
+): Promise<T> {
+	const absPath = resolve(contextCwd(), filePath);
+
+	if (isDirectoryPath(absPath)) {
+		throw new LspInvalidPathError(
+			"Directory paths are not supported by this LSP tool. " +
+				"Use lsp.diagnostics with a directory path for directory diagnostics.",
+		);
+	}
+
+	const ext = effectiveExtension(absPath);
+	const result = findServerForExtension(ext);
+	if (result.status !== "found") {
+		throw new LspServerLookupError(formatServerLookupError(result));
+	}
+
+	const server = result.server;
+	const root = findWorkspaceRoot(absPath);
+	const manager = options.manager ?? getLspManager();
+
+	const acquireAndCall = async (allowRetry: boolean): Promise<T> => {
+		const client = await manager.getClient(root, server, options.signal);
+
+		try {
+			return await fn(client, root);
+		} catch (err) {
+			if (allowRetry && READ_ONLY_RETRY_TOOLS.has(toolName) && isLspDeadConnectionError(err)) {
+				manager.invalidateClient(root, server.id, client);
+				return acquireAndCall(false);
+			}
+
+			if (err instanceof LspRequestTimeoutError) {
+				if (manager.isServerInitializing(root, server.id)) {
+					throw new LspServerInitializingError(err);
+				}
+			}
+			throw err;
+		} finally {
+			manager.releaseClient(root, server.id);
+		}
+	};
+
+	return acquireAndCall(true);
+}

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

@@ -0,0 +1,172 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { contextCwd } from "../request-context.js";
+import { LspClientConnection } from "./connection.js";
+import { effectiveExtension } from "./effective-extension.js";
+import { getLanguageId } from "./language-mappings.js";
+import type {
+	Diagnostic,
+	DocumentSymbol,
+	Location,
+	LocationLink,
+	PrepareRenameDefaultBehavior,
+	PrepareRenameResult,
+	Range,
+	SymbolInfo,
+	WorkspaceEdit,
+} from "./types.js";
+
+const POST_OPEN_DELAY_MS = 1000;
+const POST_DIAGNOSTICS_WAIT_MS = 500;
+
+export class LspClient extends LspClientConnection {
+	private readonly openedFiles = new Set<string>();
+	private readonly documentVersions = new Map<string, number>();
+	private readonly lastSyncedText = new Map<string, string>();
+	private readonly diagnosticPullErrors: Error[] = [];
+
+	getDiagnosticPullErrors(): readonly Error[] {
+		return this.diagnosticPullErrors;
+	}
+
+	async openFile(filePath: string): Promise<void> {
+		const absPath = resolve(contextCwd(), filePath);
+		const uri = pathToFileURL(absPath).href;
+		const text = readFileSync(absPath, "utf-8");
+
+		if (!this.openedFiles.has(absPath)) {
+			const ext = effectiveExtension(absPath);
+			const languageId = getLanguageId(ext);
+			const version = 1;
+
+			await this.sendNotification("textDocument/didOpen", {
+				textDocument: {
+					uri,
+					languageId,
+					version,
+					text,
+				},
+			});
+
+			this.openedFiles.add(absPath);
+			this.documentVersions.set(uri, version);
+			this.lastSyncedText.set(uri, text);
+			await new Promise((r) => setTimeout(r, POST_OPEN_DELAY_MS));
+			return;
+		}
+
+		const prevText = this.lastSyncedText.get(uri);
+		if (prevText === text) {
+			return;
+		}
+
+		const nextVersion = (this.documentVersions.get(uri) ?? 1) + 1;
+		this.documentVersions.set(uri, nextVersion);
+		this.lastSyncedText.set(uri, text);
+
+		await this.sendNotification("textDocument/didChange", {
+			textDocument: { uri, version: nextVersion },
+			contentChanges: [{ text }],
+		});
+
+		await this.sendNotification("textDocument/didSave", {
+			textDocument: { uri },
+			text,
+		});
+	}
+
+	async definition(
+		filePath: string,
+		line: number,
+		character: number,
+	): Promise<Location | LocationLink | Array<Location | LocationLink> | null> {
+		const absPath = resolve(contextCwd(), filePath);
+		await this.openFile(absPath);
+		return this.sendRequest<Location | LocationLink | Array<Location | LocationLink> | null>(
+			"textDocument/definition",
+			{
+				textDocument: { uri: pathToFileURL(absPath).href },
+				position: { line: line - 1, character },
+			},
+		);
+	}
+
+	async references(filePath: string, line: number, character: number, includeDeclaration = true): Promise<Location[]> {
+		const absPath = resolve(contextCwd(), filePath);
+		await this.openFile(absPath);
+		return this.sendRequest<Location[]>("textDocument/references", {
+			textDocument: { uri: pathToFileURL(absPath).href },
+			position: { line: line - 1, character },
+			context: { includeDeclaration },
+		});
+	}
+
+	async documentSymbols(filePath: string): Promise<Array<DocumentSymbol | SymbolInfo>> {
+		const absPath = resolve(contextCwd(), filePath);
+		await this.openFile(absPath);
+		return this.sendRequest<Array<DocumentSymbol | SymbolInfo>>("textDocument/documentSymbol", {
+			textDocument: { uri: pathToFileURL(absPath).href },
+		});
+	}
+
+	async workspaceSymbols(query: string): Promise<SymbolInfo[]> {
+		return this.sendRequest<SymbolInfo[]>("workspace/symbol", { query });
+	}
+
+	private isUnsupportedDiagnosticPullError(error: unknown): boolean {
+		if (!(error instanceof Error)) return false;
+		const code = "code" in error && typeof error.code === "number" ? error.code : undefined;
+		if (code === -32601) return true;
+		return /unsupported|not supported|method not found|unknown request/i.test(error.message);
+	}
+
+	async diagnostics(filePath: string): Promise<{ items: Diagnostic[] }> {
+		const absPath = resolve(contextCwd(), filePath);
+		const uri = pathToFileURL(absPath).href;
+		await this.openFile(absPath);
+		await new Promise((r) => setTimeout(r, POST_DIAGNOSTICS_WAIT_MS));
+
+		try {
+			const result = await this.sendRequest<{ items?: Diagnostic[] }>("textDocument/diagnostic", {
+				textDocument: { uri },
+			});
+			if (result.items) {
+				return { items: result.items };
+			}
+		} catch (error) {
+			if (!this.isUnsupportedDiagnosticPullError(error)) {
+				this.diagnosticPullErrors.push(error instanceof Error ? error : new Error(String(error)));
+			}
+		}
+
+		return { items: this.getStoredDiagnostics(uri) };
+	}
+
+	async prepareRename(
+		filePath: string,
+		line: number,
+		character: number,
+	): Promise<PrepareRenameResult | PrepareRenameDefaultBehavior | Range | null> {
+		const absPath = resolve(contextCwd(), filePath);
+		await this.openFile(absPath);
+		return this.sendRequest<PrepareRenameResult | PrepareRenameDefaultBehavior | Range | null>(
+			"textDocument/prepareRename",
+			{
+				textDocument: { uri: pathToFileURL(absPath).href },
+				position: { line: line - 1, character },
+			},
+		);
+	}
+
+	async rename(filePath: string, line: number, character: number, newName: string): Promise<WorkspaceEdit | null> {
+		const absPath = resolve(contextCwd(), filePath);
+		await this.openFile(absPath);
+		return this.sendRequest<WorkspaceEdit | null>("textDocument/rename", {
+			textDocument: { uri: pathToFileURL(absPath).href },
+			position: { line: line - 1, character },
+			newName,
+		});
+	}
+}

package/packages/lsp-core/src/lsp/config-loader.ts

@@ -0,0 +1,266 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, isAbsolute, join } from "node:path";
+
+import { contextCwd, contextEnv } from "../request-context.js";
+import { BUILTIN_SERVERS } from "./server-definitions.js";
+import type { ResolvedServer } from "./types.js";
+
+interface LspEntry {
+	disabled?: boolean;
+	command?: string[];
+	extensions?: string[];
+	priority?: number;
+	env?: Record<string, string>;
+	initialization?: Record<string, unknown>;
+}
+
+interface ConfigJson {
+	lsp?: Record<string, unknown>;
+}
+
+type ConfigSource = "project" | "user";
+
+export interface ServerWithSource extends ResolvedServer {
+	source: "project" | "user" | "builtin";
+}
+
+export function getConfigPaths(): { project: string; user: string } {
+	return {
+		project: getProjectConfigPaths()[0] ?? join(process.cwd(), ".codex", "lsp-client.json"),
+		user: getUserConfigPath(),
+	};
+}
+
+function resolveProjectConfigPath(path: string): string {
+	return isAbsolute(path) ? path : join(contextCwd(), path);
+}
+
+function getProjectConfigPaths(): string[] {
+	const projectOverride = contextEnv("LSP_TOOLS_MCP_PROJECT_CONFIG");
+	if (projectOverride) {
+		return projectOverride.split(delimiter).filter(Boolean).map(resolveProjectConfigPath);
+	}
+	return [join(contextCwd(), ".codex", "lsp-client.json")];
+}
+
+function getUserConfigPath(): string {
+	const userOverride = contextEnv("LSP_TOOLS_MCP_USER_CONFIG");
+	if (!userOverride) return join(homedir(), ".codex", "lsp-client.json");
+	return isAbsolute(userOverride) ? userOverride : join(homedir(), userOverride);
+}
+
+function loadJsonFile(path: string): ConfigJson | null {
+	if (!existsSync(path)) return null;
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(path, "utf-8"));
+		return isConfigJson(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+
+export function loadAllConfigs(): Map<ConfigSource, ConfigJson> {
+	const configs = new Map<ConfigSource, ConfigJson>();
+
+	const project = loadFirstJsonFile(getProjectConfigPaths());
+	if (project) configs.set("project", project);
+
+	const user = loadJsonFile(getUserConfigPath());
+	if (user) configs.set("user", user);
+
+	return configs;
+}
+
+function loadFirstJsonFile(paths: readonly string[]): ConfigJson | null {
+	for (const path of paths) {
+		const config = loadJsonFile(path);
+		if (config) return config;
+	}
+	return null;
+}
+
+export function getMergedServers(): ServerWithSource[] {
+	const configs = loadAllConfigs();
+	const servers: ServerWithSource[] = [];
+	const disabled = new Set<string>();
+	const seen = new Set<string>();
+
+	const sources: ConfigSource[] = ["project", "user"];
+
+	for (const source of sources) {
+		const config = configs.get(source);
+		if (!config?.lsp) continue;
+
+		for (const [id, rawEntry] of Object.entries(config.lsp)) {
+			const entry = parseLspEntry(rawEntry);
+			if (!entry) continue;
+			if (entry.disabled) {
+				disabled.add(id);
+				continue;
+			}
+
+			if (seen.has(id)) continue;
+			const server = createServerFromEntry(id, entry, source);
+			if (!server) continue;
+
+			servers.push(server);
+			seen.add(id);
+		}
+	}
+
+	for (const [id, config] of Object.entries(BUILTIN_SERVERS)) {
+		if (disabled.has(id) || seen.has(id)) continue;
+
+		servers.push({
+			id,
+			command: config.command,
+			extensions: config.extensions,
+			priority: -100,
+			source: "builtin",
+		});
+	}
+
+	return servers.sort((a, b) => {
+		if (a.source !== b.source) {
+			const order: Record<"project" | "user" | "builtin", number> = {
+				project: 0,
+				user: 1,
+				builtin: 2,
+			};
+			return order[a.source] - order[b.source];
+		}
+		return b.priority - a.priority;
+	});
+}
+
+function createServerFromEntry(id: string, entry: LspEntry, source: ConfigSource): ServerWithSource | null {
+	const builtin = BUILTIN_SERVERS[id];
+	if (source === "project") {
+		if (!builtin) return null;
+		const server = createServer({
+			id,
+			command: builtin.command,
+			extensions: entry.extensions ?? builtin.extensions,
+			priority: entry.priority ?? 0,
+			source,
+		});
+		if (entry.initialization !== undefined) {
+			server.initialization = entry.initialization;
+		}
+		return server;
+	}
+
+	if (entry.command && entry.extensions) {
+		const server = createServer({
+			id,
+			command: entry.command,
+			extensions: entry.extensions,
+			priority: entry.priority ?? 0,
+			source,
+		});
+		applyOptionalServerFields(server, entry);
+		return server;
+	}
+
+	if (!builtin) return null;
+	const server = createServer({
+		id,
+		command: entry.command ?? builtin.command,
+		extensions: entry.extensions ?? builtin.extensions,
+		priority: entry.priority ?? 0,
+		source,
+	});
+	applyOptionalServerFields(server, entry);
+	return server;
+}
+
+function createServer(input: {
+	readonly id: string;
+	readonly command: string[];
+	readonly extensions: string[];
+	readonly priority: number;
+	readonly source: ConfigSource;
+	readonly env?: Record<string, string>;
+	readonly initialization?: Record<string, unknown>;
+}): ServerWithSource {
+	const server: ServerWithSource = {
+		id: input.id,
+		command: input.command,
+		extensions: input.extensions,
+		priority: input.priority,
+		source: input.source,
+	};
+	if (input.env !== undefined) {
+		server.env = input.env;
+	}
+	if (input.initialization !== undefined) {
+		server.initialization = input.initialization;
+	}
+	return server;
+}
+
+function applyOptionalServerFields(server: ServerWithSource, entry: LspEntry): void {
+	if (entry.env !== undefined) {
+		server.env = entry.env;
+	}
+	if (entry.initialization !== undefined) {
+		server.initialization = entry.initialization;
+	}
+}
+
+function isConfigJson(value: unknown): value is ConfigJson {
+	if (!isRecord(value)) return false;
+	const lsp = value["lsp"];
+	return lsp === undefined || isRecord(lsp);
+}
+
+function parseLspEntry(value: unknown): LspEntry | null {
+	return isLspEntry(value) ? value : null;
+}
+
+function isLspEntry(value: unknown): value is LspEntry {
+	if (!isRecord(value)) return false;
+	const disabled = value["disabled"];
+	const command = value["command"];
+	const extensions = value["extensions"];
+	const priority = value["priority"];
+	const env = value["env"];
+	const initialization = value["initialization"];
+	return (
+		(disabled === undefined || typeof disabled === "boolean") &&
+		(command === undefined || isStringArray(command)) &&
+		(extensions === undefined || isStringArray(extensions)) &&
+		(priority === undefined || typeof priority === "number") &&
+		(env === undefined || isStringRecord(env)) &&
+		(initialization === undefined || isRecord(initialization))
+	);
+}
+
+function isStringArray(value: unknown): value is string[] {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+function isStringRecord(value: unknown): value is Record<string, string> {
+	return isRecord(value) && Object.values(value).every((item) => typeof item === "string");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function getDisabledServerIds(): Set<string> {
+	const configs = loadAllConfigs();
+	const disabled = new Set<string>();
+
+	for (const config of configs.values()) {
+		if (!config.lsp) continue;
+		for (const [id, rawEntry] of Object.entries(config.lsp)) {
+			const entry = parseLspEntry(rawEntry);
+			if (!entry) continue;
+			if (entry.disabled) disabled.add(id);
+		}
+	}
+
+	return disabled;
+}

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

@@ -0,0 +1,73 @@
+import { pathToFileURL } from "node:url";
+
+import { LspClientTransport } from "./transport.js";
+
+const INITIALIZE_SETTLE_MS = 300;
+
+export class LspClientConnection extends LspClientTransport {
+	async initialize(): Promise<void> {
+		const rootUri = pathToFileURL(this.root).href;
+		await this.sendRequest(
+			"initialize",
+			{
+				processId: process.pid,
+				rootUri,
+				rootPath: this.root,
+				workspaceFolders: [{ uri: rootUri, name: "workspace" }],
+				capabilities: {
+					textDocument: {
+						hover: { contentFormat: ["markdown", "plaintext"] },
+						definition: { linkSupport: true },
+						references: {},
+						documentSymbol: { hierarchicalDocumentSymbolSupport: true },
+						publishDiagnostics: {},
+						rename: {
+							prepareSupport: true,
+							prepareSupportDefaultBehavior: 1,
+							honorsChangeAnnotations: true,
+						},
+						codeAction: {
+							codeActionLiteralSupport: {
+								codeActionKind: {
+									valueSet: [
+										"quickfix",
+										"refactor",
+										"refactor.extract",
+										"refactor.inline",
+										"refactor.rewrite",
+										"source",
+										"source.organizeImports",
+										"source.fixAll",
+									],
+								},
+							},
+							isPreferredSupport: true,
+							disabledSupport: true,
+							dataSupport: true,
+							resolveSupport: {
+								properties: ["edit", "command"],
+							},
+						},
+					},
+					workspace: {
+						symbol: {},
+						workspaceFolders: true,
+						configuration: true,
+						applyEdit: true,
+						workspaceEdit: {
+							documentChanges: true,
+						},
+					},
+				},
+				initializationOptions: this.server.initialization,
+			},
+			{ timeoutMs: this.initializeTimeoutMs },
+		);
+		await this.sendNotification("initialized");
+		await this.sendNotification("workspace/didChangeConfiguration", {
+			settings: { json: { validate: { enable: true } } },
+		});
+		// Some servers accept initialized before their diagnostics/indexing handlers are ready.
+		await new Promise((r) => setTimeout(r, INITIALIZE_SETTLE_MS));
+	}
+}

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

@@ -0,0 +1,11 @@
+export const DEFAULT_MAX_REFERENCES = 200;
+export const DEFAULT_MAX_SYMBOLS = 200;
+export const DEFAULT_MAX_DIAGNOSTICS = 200;
+export const DEFAULT_MAX_DIRECTORY_FILES = 50;
+
+export const REQUEST_TIMEOUT_MS = 15_000;
+export const INIT_TIMEOUT_MS = 60_000;
+export const IDLE_TIMEOUT_MS = 5 * 60_000;
+export const REAPER_INTERVAL_MS = 60_000;
+export const STOP_HARD_KILL_TIMEOUT_MS = 5_000;
+export const STOP_SIGKILL_GRACE_MS = 1_000;