oh-my-opencode 4.18.0 → 4.18.2

package/packages/lsp-core/src/lsp/workspace-mutation-controller.ts

@@ -0,0 +1,182 @@
+import type { WorkspaceEdit } from "./types.js";
+import { workspaceApplyEditConcurrentFailureReason } from "./workspace-apply-edit-failure.js";
+import { commitWorkspaceEditPlan } from "./workspace-edit-commit.js";
+import { fingerprintWorkspaceEdit, planWorkspaceEdit } from "./workspace-edit-plan.js";
+import type {
+	ApplyResult,
+	LspRenameResult,
+	WorkspaceEditCommitIo,
+} from "./workspace-edit-types.js";
+import { WorkspaceDocumentState } from "./workspace-document-state.js";
+
+export interface WorkspaceApplyEditResponse {
+	readonly applied: boolean;
+	readonly failureReason?: string;
+	readonly failedChange?: number;
+}
+
+export interface WorkspaceMutationLease {
+	readonly id: number;
+}
+
+interface ServerApplyRecord {
+	readonly fingerprint: string | null;
+	readonly result: ApplyResult;
+}
+
+interface ActiveLease extends WorkspaceMutationLease {
+	readonly signal?: AbortSignal;
+	phase: "idle" | "applying" | "settled" | "sealed";
+	serverApply?: ServerApplyRecord;
+	applyCompletion?: Promise<void>;
+	resolveApply?: () => void;
+}
+
+export type AcquireMutationLeaseResult =
+	| { readonly success: true; readonly lease: WorkspaceMutationLease }
+	| { readonly success: false; readonly result: ApplyResult };
+
+function failure(message: string, failedChange?: number, base?: ApplyResult): ApplyResult {
+	return {
+		success: false,
+		filesModified: base?.filesModified ?? [],
+		totalEdits: base?.totalEdits ?? 0,
+		errors: [message],
+		...(failedChange === undefined ? {} : { failedChange }),
+		...(base?.lateAbort ? { lateAbort: true } : {}),
+	};
+}
+
+function responseFor(result: ApplyResult): WorkspaceApplyEditResponse {
+	if (result.success) return { applied: true };
+	return {
+		applied: false,
+		failureReason: result.errors[0] ?? "workspace edit failed",
+		...(result.failedChange === undefined ? {} : { failedChange: result.failedChange }),
+	};
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export class WorkspaceMutationController {
+	private activeLease: ActiveLease | null = null;
+	private nextLeaseId = 1;
+	private io: Partial<WorkspaceEditCommitIo> | undefined;
+
+	constructor(
+		private readonly workspaceRoot: string,
+		private readonly documents: WorkspaceDocumentState,
+	) {}
+
+	setIo(io: Partial<WorkspaceEditCommitIo>): void {
+		this.io = io;
+	}
+
+	acquire(signal?: AbortSignal): AcquireMutationLeaseResult {
+		if (this.activeLease) return { success: false, result: failure("workspace mutation is already in progress") };
+		if (signal?.aborted) return { success: false, result: failure("cancelled before mutating request") };
+		const lease: ActiveLease = {
+			id: this.nextLeaseId,
+			phase: "idle",
+			...(signal === undefined ? {} : { signal }),
+		};
+		this.nextLeaseId += 1;
+		this.activeLease = lease;
+		return { success: true, lease };
+	}
+
+	release(lease: WorkspaceMutationLease): void {
+		if (this.activeLease?.id !== lease.id) return;
+		this.activeLease.phase = "sealed";
+		this.activeLease = null;
+	}
+
+	isBeforeCommit(lease: WorkspaceMutationLease): boolean {
+		return this.activeLease?.id === lease.id && this.activeLease.phase === "idle";
+	}
+
+	async handleApplyEdit(params: unknown): Promise<WorkspaceApplyEditResponse> {
+		const lease = this.activeLease;
+		if (!lease) return { applied: false, failureReason: "workspace/applyEdit requires an active workspace mutation" };
+		if (lease.phase !== "idle") {
+			return {
+				applied: false,
+				failureReason: workspaceApplyEditConcurrentFailureReason(lease.phase === "applying" ? "applying" : "settled"),
+			};
+		}
+
+		lease.phase = "applying";
+		lease.applyCompletion = new Promise<void>((resolve) => {
+			lease.resolveApply = resolve;
+		});
+		const edit = isRecord(params) ? params["edit"] : undefined;
+		const record =
+			edit === undefined
+				? { fingerprint: null, result: failure("workspace/applyEdit params.edit is required", 0) }
+				: await this.applyEdit(edit, lease);
+		lease.serverApply = record;
+		lease.phase = "settled";
+		lease.resolveApply?.();
+		return responseFor(record.result);
+	}
+
+	async reconcileRename(
+		leaseToken: WorkspaceMutationLease,
+		edit: WorkspaceEdit | null,
+	): Promise<LspRenameResult> {
+		const lease = this.requireActiveLease(leaseToken);
+		if (!lease) return { edit, apply: failure("workspace mutation lease ended before rename reconciliation") };
+		if (lease.phase === "applying") await lease.applyCompletion;
+		if (lease.serverApply) return this.reconcileServerApply(lease.serverApply, edit);
+		lease.phase = "sealed";
+		if (!edit) return { edit, apply: failure("No edit provided") };
+		const applied = await this.applyEdit(edit, lease);
+		return { edit, apply: applied.result };
+	}
+
+	private reconcileServerApply(record: ServerApplyRecord, edit: WorkspaceEdit | null): LspRenameResult {
+		if (!edit) return { edit, apply: record.result };
+		const fingerprint = fingerprintWorkspaceEdit(edit, this.workspaceRoot);
+		if (fingerprint.success && record.fingerprint !== null && fingerprint.fingerprint === record.fingerprint) {
+			return { edit, apply: record.result };
+		}
+		return {
+			edit,
+			apply: failure("rename result conflicts with server-applied workspace edit", 0, record.result),
+		};
+	}
+
+	private async applyEdit(edit: unknown, lease: ActiveLease): Promise<ServerApplyRecord> {
+		const planned = planWorkspaceEdit(edit, this.workspaceRoot);
+		if (!planned.success) return { fingerprint: null, result: planned.result };
+		const versionFailure = this.documents.validateVersions(planned.plan.operations);
+		if (versionFailure) {
+			return {
+				fingerprint: planned.plan.fingerprint,
+				result: failure(versionFailure.message, versionFailure.changeIndex),
+			};
+		}
+
+		const commit = commitWorkspaceEditPlan(planned.plan, {
+			...(lease.signal === undefined ? {} : { signal: lease.signal }),
+			...(this.io === undefined ? {} : { io: this.io }),
+		});
+		let result = commit.result;
+		if (commit.delta.operations.length > 0) {
+			try {
+				await this.documents.synchronize(commit.delta);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				result = failure(`document synchronization failed after filesystem commit: ${message}`, undefined, result);
+			}
+		}
+		if (lease.signal?.aborted && !result.lateAbort) result = { ...result, lateAbort: true };
+		return { fingerprint: planned.plan.fingerprint, result };
+	}
+
+	private requireActiveLease(lease: WorkspaceMutationLease): ActiveLease | null {
+		return this.activeLease?.id === lease.id ? this.activeLease : null;
+	}
+}

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

@@ -3,7 +3,6 @@ import {
 	errorResponse,
 	isPlainRecord,
 	jsonRpcId,
-	messageFromError,
 	runJsonRpcStdioServer,
 	successResponse,
 	type JsonRpcError,
@@ -13,13 +12,21 @@ import {
 	type McpToolDescriptor,
 } from "@oh-my-opencode/mcp-stdio-core";
 import { coerceToolArguments, executeLspTool, LSP_MCP_TOOLS } from "./tools.js";
+import { createStandaloneMcpRequestContext, runWithRequestContext } from "./request-context.js";
 
 export type { JsonRpcError, JsonRpcId, JsonRpcResponse, JsonRpcResult, McpToolDescriptor };
 
 const SERVER_NAME = "lsp";
 const SERVER_VERSION = "0.1.0";
 
-export async function handleLspMcpRequest(input: unknown): Promise<JsonRpcResponse | undefined> {
+export interface HandleLspMcpRequestOptions {
+	readonly signal?: AbortSignal;
+}
+
+export async function handleLspMcpRequest(
+	input: unknown,
+	options: HandleLspMcpRequestOptions = {},
+): Promise<JsonRpcResponse | undefined> {
 	if (!isPlainRecord(input)) {
 		return errorResponse(null, -32600, "Invalid Request");
 	}
@@ -42,7 +49,7 @@ export async function handleLspMcpRequest(input: unknown): Promise<JsonRpcRespon
 	}
 
 	if (method === "tools/call") {
-		return handleToolCall(id, input["params"]);
+		return handleToolCall(id, input["params"], options.signal);
 	}
 
 	return errorResponse(id, -32601, `Method not found: ${String(method)}`);
@@ -52,30 +59,34 @@ export async function runMcpStdioServer(
 	input: Readable = process.stdin,
 	output: Writable = process.stdout,
 ): Promise<void> {
+	const requestContext = createStandaloneMcpRequestContext();
 	await runJsonRpcStdioServer({
 		input,
 		output,
 		idleTimeoutMs: 0,
-		handler: handleLspMcpRequest,
+		handler: (request) => runWithRequestContext(requestContext, () => handleLspMcpRequest(request)),
 		handlerOptions: undefined,
 	});
 }
 
-async function handleToolCall(id: JsonRpcId, params: unknown): Promise<JsonRpcResponse> {
+async function handleToolCall(id: JsonRpcId, params: unknown, signal?: AbortSignal): Promise<JsonRpcResponse> {
 	if (!isPlainRecord(params) || typeof params["name"] !== "string") {
 		return errorResponse(id, -32602, "tools/call requires params.name");
 	}
 
 	try {
-		const result = await executeLspTool(params["name"], coerceToolArguments(params["arguments"]));
+		const result = await executeLspTool(params["name"], coerceToolArguments(params["arguments"]), signal);
 		return successResponse(id, {
 			content: result.content,
 			isError: result.isError ?? false,
 			details: result.details,
 		});
 	} catch (error) {
+		if (!(error instanceof Error)) {
+			throw error;
+		}
 		return successResponse(id, {
-			content: [{ type: "text", text: messageFromError(error) }],
+			content: [{ type: "text", text: error.message }],
 			isError: true,
 		});
 	}

package/packages/lsp-core/src/missing-dependency-result.test.ts

@@ -0,0 +1,105 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { LspServerLookupError } from "./lsp/errors.js";
+import { missingDependencyResult } from "./missing-dependency-result.js";
+import { parseLspRequestContext, runWithRequestContext } from "./request-context.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function tempRoot(): string {
+	const root = mkdtempSync(join(homedir(), "lsp-missing-dep-"));
+	tempDirectories.push(root);
+	return root;
+}
+
+describe("missingDependencyResult", () => {
+	it("#given not configured lookup #when converted #then includes structured availability and typed config paths", () => {
+		const root = tempRoot();
+		const projectConfigPath = join(root, ".codex", "lsp-client.json");
+		const userConfigPath = join(homedir(), ".codex", "lsp-client.json");
+		const installDecisionsPath = join(homedir(), ".codex", "lsp-install-decisions.json");
+		const context = parseLspRequestContext({
+			cwd: root,
+			projectConfigPaths: [projectConfigPath],
+			userConfigPath,
+			installDecisionsPath,
+			capabilities: { installDecisionTool: false },
+		});
+
+		const result = runWithRequestContext(context, () =>
+			missingDependencyResult(
+				new LspServerLookupError("No LSP server configured for extension: .foo", {
+					status: "not_configured",
+					extension: ".foo",
+					availableServers: ["typescript"],
+				}),
+				{ filePath: "src/file.foo" },
+			),
+		);
+
+		expect(result?.details).toEqual({
+			filePath: "src/file.foo",
+			error: "No LSP server configured for extension: .foo",
+			errorKind: "missing_dependency",
+			availability: {
+				kind: "not_configured",
+				extension: ".foo",
+				availableServers: ["typescript"],
+				projectConfigPaths: [projectConfigPath],
+				userConfigPath,
+				installDecisionTool: false,
+			},
+		});
+	});
+
+	it("#given not installed lookup #when converted #then includes install decision availability", () => {
+		const root = tempRoot();
+		const installDecisionsPath = join(homedir(), ".codex", "lsp-install-decisions.json");
+		const context = parseLspRequestContext({
+			cwd: root,
+			projectConfigPaths: [join(root, ".codex", "lsp-client.json")],
+			userConfigPath: join(homedir(), ".codex", "lsp-client.json"),
+			installDecisionsPath,
+			capabilities: { installDecisionTool: true },
+		});
+
+		const result = runWithRequestContext(context, () =>
+			missingDependencyResult(
+				new LspServerLookupError("LSP server 'typescript' for .ts is NOT INSTALLED.", {
+					status: "not_installed",
+					server: {
+						id: "typescript",
+						command: ["typescript-language-server", "--stdio"],
+						extensions: [".ts"],
+					},
+					installHint: "npm install -g typescript-language-server typescript",
+				}),
+				{ filePath: "src/file.ts" },
+			),
+		);
+
+		expect(result?.details).toEqual({
+			filePath: "src/file.ts",
+			error: "LSP server 'typescript' for .ts is NOT INSTALLED.",
+			errorKind: "missing_dependency",
+			availability: {
+				kind: "not_installed",
+				serverId: "typescript",
+				command: ["typescript-language-server", "--stdio"],
+				extensions: [".ts"],
+				installHint: "npm install -g typescript-language-server typescript",
+				installDecisionTool: true,
+				installDecisionsPath,
+			},
+		});
+	});
+});

package/packages/lsp-core/src/missing-dependency-result.ts

@@ -1,6 +1,27 @@
+import { LspServerLookupError } from "./lsp/errors.js";
 import { handleMissingDependencyError } from "./lsp/startup-failure.js";
+import { lspRequestContext } from "./request-context.js";
 import type { ToolExecutionResult } from "./tools.js";
 
+export type MissingDependencyAvailability =
+	| {
+			readonly kind: "not_configured";
+			readonly extension: string;
+			readonly availableServers: readonly string[];
+			readonly projectConfigPaths: readonly string[];
+			readonly userConfigPath: string;
+			readonly installDecisionTool: boolean;
+	  }
+	| {
+			readonly kind: "not_installed";
+			readonly serverId: string;
+			readonly command: readonly string[];
+			readonly extensions: readonly string[];
+			readonly installHint: string;
+			readonly installDecisionTool: boolean;
+			readonly installDecisionsPath: string;
+	  };
+
 export function missingDependencyResult<TDetails extends object>(
 	error: unknown,
 	details: TDetails,
@@ -14,6 +35,42 @@ export function missingDependencyResult<TDetails extends object>(
 			...details,
 			error: message,
 			errorKind: "missing_dependency",
+			...availabilityDetails(error),
 		},
 	};
 }
+
+function availabilityDetails(error: unknown): { readonly availability: MissingDependencyAvailability } | object {
+	const availability = missingDependencyAvailability(error);
+	return availability === null ? {} : { availability };
+}
+
+function missingDependencyAvailability(error: unknown): MissingDependencyAvailability | null {
+	if (!(error instanceof LspServerLookupError) || error.lookup === undefined) return null;
+	const context = lspRequestContext();
+	switch (error.lookup.status) {
+		case "not_configured":
+			return {
+				kind: "not_configured",
+				extension: error.lookup.extension,
+				availableServers: [...error.lookup.availableServers],
+				projectConfigPaths: [...context.projectConfigPaths],
+				userConfigPath: context.userConfigPath,
+				installDecisionTool: context.capabilities.installDecisionTool,
+			};
+		case "not_installed":
+			return {
+				kind: "not_installed",
+				serverId: error.lookup.server.id,
+				command: [...error.lookup.server.command],
+				extensions: [...error.lookup.server.extensions],
+				installHint: error.lookup.installHint,
+				installDecisionTool: context.capabilities.installDecisionTool,
+				installDecisionsPath: context.installDecisionsPath,
+			};
+		default: {
+			const exhaustive: never = error.lookup;
+			return exhaustive;
+		}
+	}
+}

package/packages/lsp-core/src/post-edit/index.ts

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

package/packages/lsp-core/src/post-edit/orchestration.test.ts

@@ -0,0 +1,157 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+	collectPostEditDiagnostics,
+	createPostEditNotConfiguredCache,
+	resetPostEditNotConfiguredCache,
+} from "./orchestration.js";
+
+describe("collectPostEditDiagnostics", () => {
+	it("#given rendered not_configured text #when the same extension is checked again #then the text is not cached", async () => {
+		const cache = createPostEditNotConfiguredCache();
+		let calls = 0;
+
+		const first = await collectPostEditDiagnostics({
+			filePaths: ["a.foo"],
+			cache,
+			runDiagnostics: async () => {
+				calls += 1;
+				return "No LSP server configured for extension: .foo\n\nordinary text from a renderer";
+			},
+		});
+		const second = await collectPostEditDiagnostics({
+			filePaths: ["b.foo"],
+			cache,
+			runDiagnostics: async () => {
+				calls += 1;
+				return "diagnostic for b.foo";
+			},
+		});
+
+		expect(calls).toBe(2);
+		expect(first.blocks).toEqual([
+			{ filePath: "a.foo", diagnostics: "No LSP server configured for extension: .foo\n\nordinary text from a renderer" },
+		]);
+		expect(second.blocks).toEqual([{ filePath: "b.foo", diagnostics: "diagnostic for b.foo" }]);
+		expect([...cache.notConfiguredExtensions]).toEqual([]);
+	});
+
+	it("#given duplicate edited paths #when diagnostics run #then first seen paths are processed once and blocks stay ordered", async () => {
+		const calls: string[] = [];
+
+		const result = await collectPostEditDiagnostics({
+			filePaths: ["a.ts", "b.ts", "a.ts", "c.ts"],
+			runDiagnostics: async (filePath: string) => {
+				calls.push(filePath);
+				return filePath === "b.ts" ? "No diagnostics found" : `diagnostic for ${filePath}`;
+			},
+		});
+
+		expect(calls).toEqual(["a.ts", "b.ts", "c.ts"]);
+		expect(result.blocks).toEqual([
+			{ filePath: "a.ts", diagnostics: "diagnostic for a.ts" },
+			{ filePath: "c.ts", diagnostics: "diagnostic for c.ts" },
+		]);
+	});
+
+	it("#given many edited paths #when diagnostics run #then concurrency is bounded to four and failures isolate", async () => {
+		let active = 0;
+		let maxActive = 0;
+
+		const result = await collectPostEditDiagnostics({
+			filePaths: ["a.ts", "b.ts", "c.ts", "d.ts", "e.ts", "f.ts"],
+			runDiagnostics: async (filePath: string) => {
+				active += 1;
+				maxActive = Math.max(maxActive, active);
+				await Promise.resolve();
+				active -= 1;
+				if (filePath === "c.ts") throw new Error("server exploded");
+				return filePath === "e.ts" ? "No diagnostics found" : `diagnostic for ${filePath}`;
+			},
+		});
+
+		expect(maxActive).toBe(4);
+		expect(result.blocks).toEqual([
+			{ filePath: "a.ts", diagnostics: "diagnostic for a.ts" },
+			{ filePath: "b.ts", diagnostics: "diagnostic for b.ts" },
+			{ filePath: "c.ts", diagnostics: "server exploded" },
+			{ filePath: "d.ts", diagnostics: "diagnostic for d.ts" },
+			{ filePath: "f.ts", diagnostics: "diagnostic for f.ts" },
+		]);
+	});
+
+	it("#given structured not_configured diagnostics #when cache is reused and reset #then only not_configured is cached", async () => {
+		const cache = createPostEditNotConfiguredCache();
+		const calls: string[] = [];
+		const responses = new Map<string, string | { readonly kind: "not_configured"; readonly extension: string }>([
+			["a.foo", { kind: "not_configured", extension: ".foo" }],
+			["b.foo", "diagnostic should be skipped"],
+			["c.bar", "LSP server 'bar' for .bar is NOT INSTALLED."],
+		]);
+
+		const first = await collectPostEditDiagnostics({
+			filePaths: ["a.foo", "c.bar"],
+			cache,
+			runDiagnostics: async (filePath: string) => {
+				calls.push(filePath);
+				return responses.get(filePath) ?? "No diagnostics found";
+			},
+		});
+
+		expect(calls).toEqual(["a.foo", "c.bar"]);
+		expect(first.blocks).toEqual([{ filePath: "c.bar", diagnostics: "LSP server 'bar' for .bar is NOT INSTALLED." }]);
+
+		const cached = await collectPostEditDiagnostics({
+			filePaths: ["b.foo"],
+			cache,
+			runDiagnostics: async (filePath: string) => {
+				calls.push(filePath);
+				return responses.get(filePath) ?? "No diagnostics found";
+			},
+		});
+
+		expect(cached.blocks).toEqual([]);
+		expect(calls).toEqual(["a.foo", "c.bar"]);
+
+		responses.set("a.foo", "No diagnostics found");
+		resetPostEditNotConfiguredCache(cache);
+		const second = await collectPostEditDiagnostics({
+			filePaths: ["a.foo", "b.foo"],
+			cache,
+			runDiagnostics: async (filePath: string) => {
+				calls.push(filePath);
+				return responses.get(filePath) ?? "No diagnostics found";
+			},
+		});
+
+		expect(second.blocks).toEqual([{ filePath: "b.foo", diagnostics: "diagnostic should be skipped" }]);
+		expect(calls).toEqual(["a.foo", "c.bar", "a.foo", "b.foo"]);
+	});
+
+	it("#given non-not_configured failures #when cache is reused #then every failure retries", async () => {
+		const cache = createPostEditNotConfiguredCache();
+		let calls = 0;
+
+		const first = await collectPostEditDiagnostics({
+			filePaths: ["a.foo"],
+			cache,
+			runDiagnostics: async () => {
+				calls += 1;
+				return "LSP server 'foo' for .foo is NOT INSTALLED.";
+			},
+		});
+		const second = await collectPostEditDiagnostics({
+			filePaths: ["b.foo"],
+			cache,
+			runDiagnostics: async () => {
+				calls += 1;
+				throw new Error("daemon unavailable");
+			},
+		});
+
+		expect(calls).toBe(2);
+		expect(first.blocks).toEqual([{ filePath: "a.foo", diagnostics: "LSP server 'foo' for .foo is NOT INSTALLED." }]);
+		expect(second.blocks).toEqual([{ filePath: "b.foo", diagnostics: "daemon unavailable" }]);
+		expect([...cache.notConfiguredExtensions]).toEqual([]);
+	});
+});