oh-my-opencode 4.17.1 → 4.18.1

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

@@ -0,0 +1,63 @@
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { createStandaloneMcpRequestContext, runWithRequestContext } from "../request-context.js";
+import { findWorkspaceRoot, resolvePathInsideContext } from "./client-wrapper.js";
+import { LspInvalidPathError } from "./errors.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function tempRoot(prefix: string): string {
+	const root = mkdtempSync(join(tmpdir(), prefix));
+	tempDirectories.push(root);
+	return root;
+}
+
+describe("LSP client path confinement", () => {
+	it("#given a relative file inside context cwd #when resolving workspace #then marker search stays inside cwd", () => {
+		const root = tempRoot("lsp-client-wrapper-root-");
+		mkdirSync(join(root, ".git"), { recursive: true });
+		mkdirSync(join(root, "src"), { recursive: true });
+		writeFileSync(join(root, "src", "file.ts"), "export const value = 1;\n");
+
+		const workspace = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			findWorkspaceRoot("src/file.ts"),
+		);
+
+		expect(workspace).toBe(realpathSync(root));
+	});
+
+	it("#given an absolute file outside context cwd #when resolving #then rejects before workspace inference", () => {
+		const root = tempRoot("lsp-client-wrapper-cwd-");
+		const outside = tempRoot("lsp-client-wrapper-outside-");
+		mkdirSync(join(outside, ".git"), { recursive: true });
+		writeFileSync(join(outside, "file.ts"), "export const outside = true;\n");
+
+		expect(() =>
+			runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+				findWorkspaceRoot(join(outside, "file.ts")),
+			),
+		).toThrow(LspInvalidPathError);
+	});
+
+	it("#given a symlink inside cwd that points outside #when resolving #then rejects the escape", () => {
+		const root = tempRoot("lsp-client-wrapper-symlink-root-");
+		const outside = tempRoot("lsp-client-wrapper-symlink-outside-");
+		writeFileSync(join(outside, "file.ts"), "export const outside = true;\n");
+		symlinkSync(outside, join(root, "linked"));
+
+		expect(() =>
+			runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+				resolvePathInsideContext("linked/file.ts"),
+			),
+		).toThrow(LspInvalidPathError);
+	});
+});

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

@@ -1,6 +1,11 @@
 import { existsSync, statSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { contextCwd } from "../request-context.js";
+import {
+	canonicalizeExistingOrNearestAncestor,
+	contextCwd,
+	isPathInside,
+	lspRequestContext,
+} from "../request-context.js";
 import type { LspClient } from "./client.js";
 import { effectiveExtension } from "./effective-extension.js";
 import {
@@ -26,7 +31,7 @@ export function isDirectoryPath(filePath: string): boolean {
 }
 
 export function findWorkspaceRoot(filePath: string): string {
-	const abs = resolve(contextCwd(), filePath);
+	const abs = resolvePathInsideContext(filePath);
 	let dir = abs;
 
 	if (!isDirectoryPath(dir)) {
@@ -47,10 +52,22 @@ export function findWorkspaceRoot(filePath: string): string {
 	return dirname(abs);
 }
 
+export function resolvePathInsideContext(filePath: string): string {
+	const cwd = contextCwd();
+	const abs = resolve(cwd, filePath);
+	const canonical = canonicalizeExistingOrNearestAncestor(abs);
+	if (!isPathInside(cwd, canonical)) {
+		throw new LspInvalidPathError(`LSP file path must be inside request cwd: ${filePath}`);
+	}
+	return canonical;
+}
+
 export function formatServerLookupError(result: Exclude<ServerLookupResult, { status: "found" }>): string {
 	if (result.status === "not_installed") {
 		return formatNotInstalled(result);
 	}
+	const context = lspRequestContext();
+	const firstProjectConfigPath = context.projectConfigPaths[0] ?? "<project lsp config>";
 
 	return [
 		`No LSP server configured for extension: ${result.extension}`,
@@ -59,7 +76,7 @@ export function formatServerLookupError(result: Exclude<ServerLookupResult, { st
 			result.availableServers.length > 10 ? "..." : ""
 		}`,
 		"",
-		"Configure a custom server in '.codex/lsp-client.json':",
+		`Configure a custom server in '${firstProjectConfigPath}' or '${context.userConfigPath}':`,
 		"  {",
 		'    "lsp": {',
 		'      "my-server": {',
@@ -75,6 +92,7 @@ function formatNotInstalled(result: Extract<ServerLookupResult, { status: "not_i
 	const { server, installHint } = result;
 	const extensions = server.extensions.join(", ");
 	const decision = loadInstallDecision(server.id)?.decision;
+	const context = lspRequestContext();
 
 	if (decision === "declined") {
 		return `LSP server '${server.id}' (${extensions}) is NOT INSTALLED; user previously declined installation — proceed without LSP.`;
@@ -95,6 +113,17 @@ function formatNotInstalled(result: Extract<ServerLookupResult, { status: "not_i
 		].join("\n");
 	}
 
+	if (!context.capabilities.installDecisionTool) {
+		return [
+			...header,
+			"To install, run:",
+			`  ${installHint}`,
+			"",
+			"ACTION REQUIRED — ASK THE USER whether to install this LSP server.",
+			"Install-decision recording is unavailable in this harness; proceed without LSP if the user declines.",
+		].join("\n");
+	}
+
 	return [
 		...header,
 		"To install, run:",
@@ -104,6 +133,7 @@ function formatNotInstalled(result: Extract<ServerLookupResult, { status: "not_i
 		"- 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" },`,
+		`    which writes to ${context.installDecisionsPath},`,
 		"    then ignore this message and proceed WITHOUT LSP.",
 	].join("\n");
 }
@@ -128,7 +158,7 @@ export async function withLspClient<T>(
 	toolName: string,
 	options: WithLspClientOptions = {},
 ): Promise<T> {
-	const absPath = resolve(contextCwd(), filePath);
+	const absPath = resolvePathInsideContext(filePath);
 
 	if (isDirectoryPath(absPath)) {
 		throw new LspInvalidPathError(
@@ -140,7 +170,7 @@ export async function withLspClient<T>(
 	const ext = effectiveExtension(absPath);
 	const result = findServerForExtension(ext);
 	if (result.status !== "found") {
-		throw new LspServerLookupError(formatServerLookupError(result));
+		throw new LspServerLookupError(formatServerLookupError(result), result);
 	}
 
 	const server = result.server;

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

@@ -1,11 +1,8 @@
-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 { LspClientTimeoutOptions } from "./transport.js";
 import type {
 	Diagnostic,
 	DocumentSymbol,
@@ -14,105 +11,131 @@ import type {
 	PrepareRenameDefaultBehavior,
 	PrepareRenameResult,
 	Range,
+	ResolvedServer,
 	SymbolInfo,
 	WorkspaceEdit,
 } from "./types.js";
+import { LspRequestTimeoutError } from "./errors.js";
+import { WorkspaceDocumentState } from "./workspace-document-state.js";
+import type { LspRenameResult, WorkspaceEditCommitIo } from "./workspace-edit-types.js";
+import { WorkspaceMutationController } from "./workspace-mutation-controller.js";
 
-const POST_OPEN_DELAY_MS = 1000;
-const POST_DIAGNOSTICS_WAIT_MS = 500;
+const DIAGNOSTICS_FRESHNESS_TIMEOUT_MS = 3_000;
+const VERSIONLESS_PUBLISH_QUIESCENCE_MS = 250;
+
+export interface LspDiagnosticsResult {
+	readonly items: Diagnostic[];
+	readonly transientError?: {
+		readonly kind: "freshness_timeout";
+		readonly message: string;
+	};
+}
+
+export interface LspClientOptions extends LspClientTimeoutOptions {
+	readonly diagnosticsFreshnessTimeoutMs?: number;
+	readonly versionlessPublishQuiescenceMs?: number;
+}
 
 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[] = [];
+	private readonly documents: WorkspaceDocumentState;
+	private readonly workspaceMutations: WorkspaceMutationController;
+	private readonly diagnosticsFreshnessTimeoutMs: number;
+
+	constructor(root: string, server: ResolvedServer, options: LspClientOptions = {}) {
+		super(root, server, options);
+		this.diagnosticsFreshnessTimeoutMs =
+			options.diagnosticsFreshnessTimeoutMs ?? DIAGNOSTICS_FRESHNESS_TIMEOUT_MS;
+		this.documents = new WorkspaceDocumentState(
+			(method, params) => this.sendNotification(method, params),
+			(uri) => this.diagnosticsStore.delete(uri),
+			{
+				versionlessPublishQuiescenceMs:
+					options.versionlessPublishQuiescenceMs ?? VERSIONLESS_PUBLISH_QUIESCENCE_MS,
+			},
+		);
+		this.workspaceMutations = new WorkspaceMutationController(root, this.documents);
+		this.setWorkspaceApplyEditHandler((params) => this.workspaceMutations.handleApplyEdit(params));
+	}
 
 	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 absPath = this.resolveWorkspacePath(filePath);
+		await this.documents.openFile(absPath);
+	}
 
-		const prevText = this.lastSyncedText.get(uri);
-		if (prevText === text) {
-			return;
-		}
+	getOpenDocumentVersion(filePath: string): number | undefined {
+		return this.documents.getVersion(this.resolveWorkspacePath(filePath));
+	}
 
-		const nextVersion = (this.documentVersions.get(uri) ?? 1) + 1;
-		this.documentVersions.set(uri, nextVersion);
-		this.lastSyncedText.set(uri, text);
+	override getStoredDiagnostics(uri: string): Diagnostic[] {
+		return [...this.documents.getStoredDiagnostics(uri)];
+	}
 
-		await this.sendNotification("textDocument/didChange", {
-			textDocument: { uri, version: nextVersion },
-			contentChanges: [{ text }],
-		});
+	setWorkspaceEditIo(io: Partial<WorkspaceEditCommitIo>): void {
+		this.workspaceMutations.setIo(io);
+	}
 
-		await this.sendNotification("textDocument/didSave", {
-			textDocument: { uri },
-			text,
-		});
+	protected override handlePublishDiagnostics(params: {
+		readonly uri: string;
+		readonly diagnostics: readonly Diagnostic[];
+		readonly version?: number;
+	}): void {
+		super.handlePublishDiagnostics(params);
+		this.documents.recordPublishedDiagnostics(params);
 	}
 
 	async definition(
 		filePath: string,
 		line: number,
 		character: number,
+		signal?: AbortSignal,
 	): Promise<Location | LocationLink | Array<Location | LocationLink> | null> {
-		const absPath = resolve(contextCwd(), filePath);
+		const absPath = this.resolveWorkspacePath(filePath);
 		await this.openFile(absPath);
+		const options = signal === undefined ? {} : { signal };
 		return this.sendRequest<Location | LocationLink | Array<Location | LocationLink> | null>(
 			"textDocument/definition",
 			{
 				textDocument: { uri: pathToFileURL(absPath).href },
 				position: { line: line - 1, character },
 			},
+			options,
 		);
 	}
 
-	async references(filePath: string, line: number, character: number, includeDeclaration = true): Promise<Location[]> {
-		const absPath = resolve(contextCwd(), filePath);
+	async references(
+		filePath: string,
+		line: number,
+		character: number,
+		includeDeclaration = true,
+		signal?: AbortSignal,
+	): Promise<Location[]> {
+		const absPath = this.resolveWorkspacePath(filePath);
 		await this.openFile(absPath);
+		const options = signal === undefined ? {} : { signal };
 		return this.sendRequest<Location[]>("textDocument/references", {
 			textDocument: { uri: pathToFileURL(absPath).href },
 			position: { line: line - 1, character },
 			context: { includeDeclaration },
-		});
+		}, options);
 	}
 
-	async documentSymbols(filePath: string): Promise<Array<DocumentSymbol | SymbolInfo>> {
-		const absPath = resolve(contextCwd(), filePath);
+	async documentSymbols(filePath: string, signal?: AbortSignal): Promise<Array<DocumentSymbol | SymbolInfo>> {
+		const absPath = this.resolveWorkspacePath(filePath);
 		await this.openFile(absPath);
+		const options = signal === undefined ? {} : { signal };
 		return this.sendRequest<Array<DocumentSymbol | SymbolInfo>>("textDocument/documentSymbol", {
 			textDocument: { uri: pathToFileURL(absPath).href },
-		});
+		}, options);
 	}
 
-	async workspaceSymbols(query: string): Promise<SymbolInfo[]> {
-		return this.sendRequest<SymbolInfo[]>("workspace/symbol", { query });
+	async workspaceSymbols(query: string, signal?: AbortSignal): Promise<SymbolInfo[]> {
+		const options = signal === undefined ? {} : { signal };
+		return this.sendRequest<SymbolInfo[]>("workspace/symbol", { query }, options);
 	}
 
 	private isUnsupportedDiagnosticPullError(error: unknown): boolean {
@@ -122,51 +145,210 @@ export class LspClient extends LspClientConnection {
 		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);
+	private freshnessTimeout(absPath: string): LspDiagnosticsResult {
+		return {
+			items: [],
+			transientError: {
+				kind: "freshness_timeout",
+				message: `Timed out waiting for fresh diagnostics for ${absPath} within ${this.diagnosticsFreshnessTimeoutMs}ms.`,
+			},
+		};
+	}
+
+	private parseDiagnosticPullReport(value: { items?: Diagnostic[]; kind?: string; resultId?: string }): {
+		readonly type: "full";
+		readonly diagnostics: readonly Diagnostic[];
+		readonly resultId?: string;
+	} | {
+		readonly type: "unchanged";
+		readonly resultId?: string;
+	} {
+		if (value.kind === "unchanged") {
+			return {
+				type: "unchanged",
+				...(value.resultId === undefined ? {} : { resultId: value.resultId }),
+			};
+		}
+		return {
+			type: "full",
+			diagnostics: value.items ?? [],
+			...(value.resultId === undefined ? {} : { resultId: value.resultId }),
+		};
+	}
+
+	async diagnostics(filePath: string, signal?: AbortSignal): Promise<LspDiagnosticsResult> {
+		signal?.throwIfAborted();
+		const absPath = this.resolveWorkspacePath(filePath);
 		const uri = pathToFileURL(absPath).href;
 		await this.openFile(absPath);
-		await new Promise((r) => setTimeout(r, POST_DIAGNOSTICS_WAIT_MS));
+		const deadlineAt = Date.now() + this.diagnosticsFreshnessTimeoutMs;
 
-		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)));
+		for (;;) {
+			signal?.throwIfAborted();
+			const snapshot = this.documents.captureDiagnosticSnapshot(absPath);
+			if (!snapshot) return this.freshnessTimeout(absPath);
+			const push = this.documents.resolvePushDiagnostics(snapshot);
+			if (push.status === "ready") return { items: [...push.diagnostics] };
+
+			let pushFallbackOnly = !this.isDiagnosticPullSupported();
+			if (!pushFallbackOnly) {
+				const cached = this.documents.getPullCache(snapshot);
+				try {
+					const remainingMs = deadlineAt - Date.now();
+					if (remainingMs <= 0) return this.freshnessTimeout(absPath);
+					const result = await this.sendRequest<{ items?: Diagnostic[]; kind?: string; resultId?: string }>(
+						"textDocument/diagnostic",
+						{
+							textDocument: { uri },
+							...(cached?.resultId === undefined ? {} : { previousResultId: cached.resultId }),
+						},
+						{ timeoutMs: remainingMs, ...(signal === undefined ? {} : { signal }) },
+					);
+					if (!this.documents.isCurrentSnapshot(snapshot)) continue;
+					const report = this.parseDiagnosticPullReport(result);
+					if (report.type === "full") {
+						this.documents.recordPullDiagnostics(snapshot, {
+							kind: "full",
+							diagnostics: report.diagnostics,
+							...(report.resultId === undefined ? {} : { resultId: report.resultId }),
+						});
+						return { items: [...report.diagnostics] };
+					}
+					if (
+						cached !== null &&
+						cached.documentVersion === snapshot.version &&
+						cached.resultId === report.resultId
+					) {
+						return { items: [...cached.diagnostics] };
+					}
+				} catch (error) {
+					if (this.isUnsupportedDiagnosticPullError(error)) {
+						this.setDiagnosticPullSupported(false);
+						pushFallbackOnly = true;
+					} else if (error instanceof LspRequestTimeoutError) {
+						pushFallbackOnly = true;
+					} else {
+						this.diagnosticPullErrors.push(error instanceof Error ? error : new Error(String(error)));
+						throw error;
+					}
+				}
 			}
-		}
 
-		return { items: this.getStoredDiagnostics(uri) };
+			if (!pushFallbackOnly) continue;
+
+			const remainingMs = deadlineAt - Date.now();
+			if (remainingMs <= 0) return this.freshnessTimeout(absPath);
+			const waitMs = push.status === "wait" ? Math.min(push.waitMs, remainingMs) : remainingMs;
+			await waitForDiagnosticsActivity(this.documents.waitForDiagnosticsActivity(snapshot, waitMs), signal);
+		}
 	}
 
 	async prepareRename(
 		filePath: string,
 		line: number,
 		character: number,
+		signal?: AbortSignal,
 	): Promise<PrepareRenameResult | PrepareRenameDefaultBehavior | Range | null> {
-		const absPath = resolve(contextCwd(), filePath);
+		const absPath = this.resolveWorkspacePath(filePath);
 		await this.openFile(absPath);
+		const options = signal === undefined ? {} : { signal };
 		return this.sendRequest<PrepareRenameResult | PrepareRenameDefaultBehavior | Range | null>(
 			"textDocument/prepareRename",
 			{
 				textDocument: { uri: pathToFileURL(absPath).href },
 				position: { line: line - 1, character },
 			},
+			options,
 		);
 	}
 
-	async rename(filePath: string, line: number, character: number, newName: string): Promise<WorkspaceEdit | null> {
-		const absPath = resolve(contextCwd(), filePath);
+	async rename(
+		filePath: string,
+		line: number,
+		character: number,
+		newName: string,
+		signal?: AbortSignal,
+	): Promise<LspRenameResult> {
+		const absPath = this.resolveWorkspacePath(filePath);
 		await this.openFile(absPath);
-		return this.sendRequest<WorkspaceEdit | null>("textDocument/rename", {
-			textDocument: { uri: pathToFileURL(absPath).href },
-			position: { line: line - 1, character },
-			newName,
-		});
+		const acquired = this.workspaceMutations.acquire(signal);
+		if (!acquired.success) return { edit: null, apply: acquired.result };
+		const preCommitSignal = createPreCommitAbortSignal(signal, () =>
+			this.workspaceMutations.isBeforeCommit(acquired.lease),
+		);
+		try {
+			const renameParams = {
+				textDocument: { uri: pathToFileURL(absPath).href },
+				position: { line: line - 1, character },
+				newName,
+			};
+			const edit =
+				preCommitSignal === undefined
+					? await this.sendRequest<WorkspaceEdit | null>("textDocument/rename", renameParams)
+					: await this.sendRequest<WorkspaceEdit | null>("textDocument/rename", renameParams, {
+							signal: preCommitSignal.signal,
+						});
+			return await this.workspaceMutations.reconcileRename(acquired.lease, edit);
+		} finally {
+			preCommitSignal?.dispose();
+			this.workspaceMutations.release(acquired.lease);
+			}
 	}
+
+	private resolveWorkspacePath(filePath: string): string {
+		return resolve(this.root, filePath);
+	}
+}
+
+function waitForDiagnosticsActivity(wait: Promise<void>, signal: AbortSignal | undefined): Promise<void> {
+	if (!signal) return wait;
+	if (signal.aborted) return Promise.reject(abortError(signal));
+	return new Promise((resolve, reject) => {
+		const onAbort = (): void => {
+			signal.removeEventListener("abort", onAbort);
+			reject(abortError(signal));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		wait.then(
+			() => {
+				signal.removeEventListener("abort", onAbort);
+				resolve();
+			},
+			(error) => {
+				signal.removeEventListener("abort", onAbort);
+				reject(error);
+			},
+		);
+	});
+}
+
+function createPreCommitAbortSignal(
+	source: AbortSignal | undefined,
+	isBeforeCommit: () => boolean,
+): { readonly signal: AbortSignal; readonly dispose: () => void } | undefined {
+	if (!source) return undefined;
+	const controller = new AbortController();
+	const onAbort = (): void => {
+		if (isBeforeCommit() && !controller.signal.aborted) controller.abort(preCommitAbortReason(source));
+	};
+	if (source.aborted) onAbort();
+	else source.addEventListener("abort", onAbort, { once: true });
+	return {
+		signal: controller.signal,
+		dispose: () => source.removeEventListener("abort", onAbort),
+	};
+}
+
+function preCommitAbortReason(source: AbortSignal): Error {
+	const reason = source.reason;
+	if (reason instanceof Error && reason.name !== "AbortError") return reason;
+	return new Error("LSP request cancelled before workspace edit commit");
+}
+
+function abortError(signal: AbortSignal): Error {
+	const reason = signal.reason;
+	if (reason instanceof Error) return reason;
+	const error = new Error(typeof reason === "string" ? reason : "operation cancelled");
+	error.name = "AbortError";
+	return error;
 }

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

@@ -1,8 +1,6 @@
 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 { lspRequestContext } from "../request-context.js";
 import { BUILTIN_SERVERS } from "./server-definitions.js";
 import type { ResolvedServer } from "./types.js";
 
@@ -27,27 +25,17 @@ export interface ServerWithSource extends ResolvedServer {
 
 export function getConfigPaths(): { project: string; user: string } {
 	return {
-		project: getProjectConfigPaths()[0] ?? join(process.cwd(), ".codex", "lsp-client.json"),
+		project: getProjectConfigPaths()[0] ?? lspRequestContext().projectConfigPaths[0] ?? "",
 		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 getProjectConfigPaths(): readonly string[] {
+	return lspRequestContext().projectConfigPaths;
 }
 
 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);
+	return lspRequestContext().userConfigPath;
 }
 
 function loadJsonFile(path: string): ConfigJson | null {