oh-my-opencode 4.18.0 → 4.18.1

package/packages/lsp-core/src/lsp/fixtures/workspace-edit-server.mjs

@@ -0,0 +1,215 @@
+import { appendFileSync, readFileSync } from "node:fs";
+
+const [, , scenarioPath, eventsPath] = process.argv;
+const scenario = JSON.parse(readFileSync(scenarioPath, "utf-8"));
+
+let buffer = Buffer.alloc(0);
+let nextServerRequestId = 10_000;
+let renameIndex = 0;
+let diagnosticIndex = 0;
+const pendingServerRequests = new Map();
+
+function record(event) {
+	appendFileSync(eventsPath, `${JSON.stringify(event)}\n`, "utf-8");
+}
+
+function send(message) {
+	const body = Buffer.from(JSON.stringify(message), "utf-8");
+	process.stdout.write(`Content-Length: ${body.length}\r\n\r\n`);
+	process.stdout.write(body);
+}
+
+function sendResponse(id, result) {
+	send({ jsonrpc: "2.0", id, result });
+}
+
+function sendError(id, code, message) {
+	send({ jsonrpc: "2.0", id, error: { code, message } });
+}
+
+function sendApplyEdit(edit, context) {
+	const id = nextServerRequestId;
+	nextServerRequestId += 1;
+	pendingServerRequests.set(String(id), context);
+	record({ type: "serverRequest", method: "workspace/applyEdit", id, edit });
+	send({ jsonrpc: "2.0", id, method: "workspace/applyEdit", params: { edit } });
+}
+
+function renameResult(step) {
+	if (step.renameResult === "same") return step.applyEdit ?? null;
+	if (step.renameResult === "different") return step.differentEdit ?? null;
+	if (step.renameResult === "edit") return step.renameEdit ?? null;
+	return null;
+}
+
+function finishRename(context) {
+	const result = renameResult(context.step);
+	const delay = Number(context.step.responseDelayMs ?? 0);
+	setTimeout(() => {
+		record({ type: "serverResponse", method: "textDocument/rename", result });
+		sendResponse(context.renameRequestId, result);
+	}, delay);
+}
+
+function schedulePublish(step, fallbackUri, fallbackVersion) {
+	const delay = Number(step.delayMs ?? 0);
+	setTimeout(() => {
+		const params = {
+			uri: step.uri ?? fallbackUri,
+			...(step.version === undefined ? {} : { version: step.version }),
+			diagnostics: Array.isArray(step.diagnostics) ? step.diagnostics : [],
+		};
+		record({ type: "serverNotification", method: "textDocument/publishDiagnostics", params });
+		send({ jsonrpc: "2.0", method: "textDocument/publishDiagnostics", params });
+	}, delay);
+}
+
+function publishSteps(trigger) {
+	if (!Array.isArray(scenario.publishDiagnostics)) return [];
+	return scenario.publishDiagnostics.filter((step) => step?.trigger === trigger);
+}
+
+function applyPublishSteps(trigger, fallbackUri, fallbackVersion) {
+	for (const step of publishSteps(trigger)) schedulePublish(step, fallbackUri, fallbackVersion);
+}
+
+function handleClientResponse(message) {
+	const context = pendingServerRequests.get(String(message.id));
+	if (!context) return;
+	pendingServerRequests.delete(String(message.id));
+	record({
+		type: "clientResponse",
+		method: "workspace/applyEdit",
+		result: message.result ?? null,
+		error: message.error ?? null,
+	});
+	if (context.kind === "unscoped") return;
+	if (typeof context.pendingApplyResponses === "number") {
+		context.pendingApplyResponses -= 1;
+		if (context.pendingApplyResponses > 0) return;
+		finishRename(context);
+		return;
+	}
+	if (context.step.applyTwice === true && context.applyCount === 1) {
+		sendApplyEdit(context.step.applyEdit, { ...context, applyCount: 2 });
+		return;
+	}
+	finishRename(context);
+}
+
+function handleRequest(message) {
+	if (message.method === "initialize") {
+		record({ type: "clientRequest", method: message.method, id: message.id, params: message.params });
+		sendResponse(message.id, { capabilities: scenario.capabilities ?? {} });
+		return;
+	}
+	if (message.method === "textDocument/rename") {
+		const step = scenario.renameSteps?.[renameIndex] ?? {};
+		renameIndex += 1;
+		record({ type: "clientRequest", method: message.method, id: message.id, params: message.params, renameIndex });
+		if (step.applyEdit) {
+			const context = { kind: "rename", renameRequestId: message.id, step, applyCount: 1 };
+			if (step.applyConcurrently === true) {
+				context.pendingApplyResponses = 2;
+				sendApplyEdit(step.applyEdit, context);
+				sendApplyEdit(step.applyEdit, context);
+				return;
+			}
+			const delay = Number(step.applyDelayMs ?? 0);
+			if (delay > 0) {
+				setTimeout(() => sendApplyEdit(step.applyEdit, context), delay);
+				return;
+			}
+			sendApplyEdit(step.applyEdit, context);
+			return;
+		}
+		finishRename({ renameRequestId: message.id, step });
+		return;
+	}
+	if (message.method === "textDocument/diagnostic") {
+		record({ type: "clientRequest", method: message.method, id: message.id, params: message.params, diagnosticIndex: diagnosticIndex + 1 });
+		applyPublishSteps("diagnosticRequest", message.params?.textDocument?.uri, undefined);
+		const step = Array.isArray(scenario.diagnosticResponses) ? scenario.diagnosticResponses[diagnosticIndex] : undefined;
+		diagnosticIndex += 1;
+		if (step?.action === "hang") return;
+		if (step?.action === "close") {
+			const delay = Number(step.delayMs ?? 0);
+			setTimeout(() => process.exit(0), delay);
+			return;
+		}
+		const delay = Number(step?.delayMs ?? 0);
+		setTimeout(() => {
+			if (step?.error) {
+				record({ type: "serverError", method: "textDocument/diagnostic", error: step.error });
+				sendError(message.id, step.error.code, step.error.message);
+				return;
+			}
+			const result = step?.report ?? { items: scenario.diagnostics ?? [] };
+			record({ type: "serverResponse", method: "textDocument/diagnostic", result });
+			sendResponse(message.id, result);
+		}, delay);
+		return;
+	}
+	if (message.method === "shutdown") {
+		sendResponse(message.id, null);
+		return;
+	}
+	sendResponse(message.id, null);
+}
+
+function handleNotification(message) {
+	record({ type: "clientNotification", method: message.method, params: message.params ?? null });
+	if (message.method === "initialized" && scenario.unscopedApplyEdit) {
+		sendApplyEdit(scenario.unscopedApplyEdit, { kind: "unscoped" });
+	}
+	if (message.method === "initialized") {
+		applyPublishSteps("initialized", undefined, undefined);
+	}
+	if (message.method === "textDocument/didOpen") {
+		applyPublishSteps("didOpen", message.params.textDocument.uri, message.params.textDocument.version);
+	}
+	if (message.method === "textDocument/didChange" && Array.isArray(scenario.diagnostics)) {
+		send({
+			jsonrpc: "2.0",
+			method: "textDocument/publishDiagnostics",
+			params: {
+				uri: message.params.textDocument.uri,
+				version: message.params.textDocument.version,
+				diagnostics: scenario.diagnostics,
+			},
+		});
+	}
+	if (message.method === "textDocument/didChange") {
+		applyPublishSteps("didChange", message.params.textDocument.uri, message.params.textDocument.version);
+	}
+	if (message.method === "exit") process.exit(0);
+}
+
+function handleMessage(message) {
+	if (Object.hasOwn(message, "id") && (Object.hasOwn(message, "result") || Object.hasOwn(message, "error"))) {
+		handleClientResponse(message);
+		return;
+	}
+	if (Object.hasOwn(message, "id")) {
+		handleRequest(message);
+		return;
+	}
+	handleNotification(message);
+}
+
+process.stdin.on("data", (chunk) => {
+	buffer = Buffer.concat([buffer, chunk]);
+	for (;;) {
+		const headerEnd = buffer.indexOf("\r\n\r\n");
+		if (headerEnd === -1) return;
+		const header = buffer.subarray(0, headerEnd).toString("ascii");
+		const match = /content-length:\s*(\d+)/i.exec(header);
+		if (!match) process.exit(2);
+		const length = Number(match[1]);
+		const bodyStart = headerEnd + 4;
+		if (buffer.length < bodyStart + length) return;
+		const body = buffer.subarray(bodyStart, bodyStart + length).toString("utf-8");
+		buffer = buffer.subarray(bodyStart + length);
+		handleMessage(JSON.parse(body));
+	}
+});

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

@@ -127,6 +127,9 @@ export function formatApplyResult(result: ApplyResult): string {
 		for (const file of result.filesModified) {
 			lines.push(`  - ${file}`);
 		}
+		if (result.lateAbort) {
+			lines.push("Cancellation arrived after the filesystem commit began; the committed edit completed.");
+		}
 	} else {
 		lines.push("Failed to apply some changes:");
 		for (const err of result.errors) {

package/packages/lsp-core/src/lsp/json-rpc-connection-cancellation.test.ts

@@ -0,0 +1,97 @@
+import { PassThrough } from "node:stream";
+
+import { describe, expect, it } from "bun:test";
+
+import { JsonRpcConnection } from "./json-rpc-connection.js";
+
+type JsonMessage = Record<string, unknown>;
+
+function messageId(message: JsonMessage): string | number | null | undefined {
+	const id = message["id"];
+	return typeof id === "string" || typeof id === "number" || id === null ? id : undefined;
+}
+
+function cancelTarget(message: JsonMessage): string | number | undefined {
+	const params = message["params"];
+	if (!params || typeof params !== "object" || Array.isArray(params)) return undefined;
+	const id = Reflect.get(params, "id");
+	return typeof id === "string" || typeof id === "number" ? id : undefined;
+}
+
+function encodeMessage(message: JsonMessage): string {
+	const body = JSON.stringify(message);
+	return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+
+function recordJsonRpcMessages(stream: PassThrough) {
+	const messages: JsonMessage[] = [];
+	const waiters: Array<() => void> = [];
+	let buffer = Buffer.alloc(0);
+	stream.on("data", (chunk: Buffer) => {
+		buffer = Buffer.concat([buffer, chunk]);
+		for (;;) {
+			const headerEnd = buffer.indexOf("\r\n\r\n");
+			if (headerEnd === -1) return;
+			const header = buffer.subarray(0, headerEnd).toString("ascii");
+			const match = /content-length:\s*(\d+)/i.exec(header);
+			if (!match?.[1]) throw new Error("missing content-length");
+			const bodyStart = headerEnd + 4;
+			const bodyEnd = bodyStart + Number.parseInt(match[1], 10);
+			if (buffer.length < bodyEnd) return;
+			const parsed: unknown = JSON.parse(buffer.subarray(bodyStart, bodyEnd).toString("utf8"));
+			buffer = buffer.subarray(bodyEnd);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+				messages.push(Object.fromEntries(Object.entries(parsed)));
+			}
+			for (const wake of waiters.splice(0)) wake();
+		}
+	});
+	return {
+		messages,
+		waitForCount(count: number): Promise<void> {
+			if (messages.length >= count) return Promise.resolve();
+			return new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					reject(new Error(`waited for ${count} JSON-RPC messages, observed ${messages.length}`));
+				}, 1_000);
+				const wake = (): void => {
+					if (messages.length < count) {
+						waiters.push(wake);
+						return;
+					}
+					clearTimeout(timer);
+					resolve();
+				};
+				waiters.push(wake);
+			});
+		},
+	};
+}
+
+describe("JsonRpcConnection cancellation", () => {
+	it("#given an active request #when its signal aborts #then cancel uses the same id and late responses are ignored", async () => {
+		const serverToClient = new PassThrough();
+		const clientToServer = new PassThrough();
+		const recorder = recordJsonRpcMessages(clientToServer);
+		const connection = new JsonRpcConnection(serverToClient, clientToServer);
+		connection.listen();
+		const controller = new AbortController();
+
+		const request = connection.sendRequest("textDocument/diagnostic", { textDocument: { uri: "file:///a.ts" } }, {
+			signal: controller.signal,
+		});
+		await recorder.waitForCount(1);
+		const requestId = messageId(recorder.messages[0] ?? {});
+		expect(typeof requestId === "string" || typeof requestId === "number").toBe(true);
+
+		controller.abort(new Error("caller cancelled"));
+		await recorder.waitForCount(2);
+		await expect(request).rejects.toThrow("caller cancelled");
+		expect(connection.pendingRequestCount()).toBe(0);
+		expect(recorder.messages[1]?.["method"]).toBe("$/cancelRequest");
+		expect(cancelTarget(recorder.messages[1] ?? {})).toBe(typeof requestId === "number" || typeof requestId === "string" ? requestId : undefined);
+
+		serverToClient.write(encodeMessage({ jsonrpc: "2.0", id: requestId ?? null, result: { items: [] } }));
+		expect(connection.pendingRequestCount()).toBe(0);
+	});
+});

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

@@ -3,11 +3,16 @@ type JsonRpcId = number | string | null;
 interface PendingRequest {
 	resolve(result: unknown): void;
 	reject(error: Error): void;
+	cleanup(): void;
 }
 
 type NotificationHandler = (params: unknown) => void;
 type RequestHandler = (params: unknown) => Promise<unknown> | unknown;
 
+export interface JsonRpcRequestOptions {
+	readonly signal?: AbortSignal;
+}
+
 const HEADER_SEPARATOR = "\r\n\r\n";
 const PARSE_ERROR = -32700;
 const INVALID_REQUEST = -32600;
@@ -56,32 +61,81 @@ export class JsonRpcConnection {
 		this.errorHandlers.push(handler);
 	}
 
-	async sendRequest<T>(method: string, params?: unknown): Promise<T> {
+	async sendRequest<T>(method: string, params?: unknown, options: JsonRpcRequestOptions = {}): Promise<T> {
 		if (this.disposed) throw new Error("JSON-RPC connection is disposed");
 
 		const id = this.nextRequestId;
 		this.nextRequestId += 1;
+		const key = String(id);
 		const message = params === undefined ? { jsonrpc: "2.0", id, method } : { jsonrpc: "2.0", id, method, params };
+		let requestWritten = false;
+		let cancelAfterWrite = false;
+		let settled = false;
+		const writeCancel = (): Promise<void> => this.writeMessage({ jsonrpc: "2.0", method: "$/cancelRequest", params: { id } });
 
 		const responsePromise = new Promise<T>((resolve, reject) => {
-			this.pendingRequests.set(String(id), {
+			const cleanup = (): void => {
+				options.signal?.removeEventListener("abort", onAbort);
+			};
+			const settleCancel = (): void => {
+				if (settled) return;
+				settled = true;
+				this.pendingRequests.delete(key);
+				cleanup();
+				const rejectCancelled = (): void => reject(abortError(options.signal));
+				if (!requestWritten) {
+					cancelAfterWrite = true;
+					rejectCancelled();
+					return;
+				}
+				void writeCancel().then(rejectCancelled, (error) => {
+					this.emitError(toError(error));
+					rejectCancelled();
+				});
+			};
+			const onAbort = (): void => settleCancel();
+			this.pendingRequests.set(key, {
 				resolve(result) {
+					settled = true;
+					cleanup();
 					resolve(result as T);
 				},
-				reject,
+				reject(error) {
+					settled = true;
+					cleanup();
+					reject(error);
+				},
+				cleanup,
 			});
+			if (options.signal?.aborted) {
+				settleCancel();
+				return;
+			}
+			options.signal?.addEventListener("abort", onAbort, { once: true });
 		});
 
+		if (settled) return responsePromise;
 		try {
 			await this.writeMessage(message);
+			requestWritten = true;
+			if (cancelAfterWrite) await writeCancel();
 		} catch (error) {
-			this.pendingRequests.delete(String(id));
+			if (settled) return responsePromise;
+			const pending = this.pendingRequests.get(key);
+			if (pending) {
+				pending.cleanup();
+				this.pendingRequests.delete(key);
+			}
 			throw error;
 		}
 
 		return responsePromise;
 	}
 
+	pendingRequestCount(): number {
+		return this.pendingRequests.size;
+	}
+
 	async sendNotification(method: string, params?: unknown): Promise<void> {
 		if (this.disposed) return;
 		const message = params === undefined ? { jsonrpc: "2.0", method } : { jsonrpc: "2.0", method, params };
@@ -97,6 +151,7 @@ export class JsonRpcConnection {
 		this.reader.off("error", this.handleStreamError);
 		this.writer.off("error", this.handleStreamError);
 		for (const pending of this.pendingRequests.values()) {
+			pending.cleanup();
 			pending.reject(new Error("JSON-RPC connection disposed"));
 		}
 		this.pendingRequests.clear();
@@ -188,6 +243,7 @@ export class JsonRpcConnection {
 		const pending = this.pendingRequests.get(String(id));
 		if (!pending) return;
 		this.pendingRequests.delete(String(id));
+		pending.cleanup();
 
 		if ("error" in message) {
 			pending.reject(jsonRpcErrorToError(message["error"]));
@@ -203,7 +259,11 @@ export class JsonRpcConnection {
 		try {
 			handler(params);
 		} catch (error) {
-			this.emitError(toError(error));
+			if (error instanceof Error) {
+				this.emitError(error);
+				return;
+			}
+			this.emitError(new Error(String(error)));
 		}
 	}
 
@@ -259,6 +319,14 @@ export class JsonRpcConnection {
 	}
 }
 
+function abortError(signal: AbortSignal | undefined): Error {
+	const reason = signal?.reason;
+	if (reason instanceof Error) return reason;
+	const error = new Error(typeof reason === "string" ? reason : "LSP request cancelled");
+	error.name = "AbortError";
+	return error;
+}
+
 function parseContentLength(headers: string): number | null {
 	for (const line of headers.split("\r\n")) {
 		const separatorIndex = line.indexOf(":");

package/packages/lsp-core/src/lsp/server-install-state.ts

@@ -1,8 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, isAbsolute, join } from "node:path";
+import { dirname } from "node:path";
 
-import { contextEnv } from "../request-context.js";
+import { lspRequestContext } from "../request-context.js";
 
 export type InstallDecision = "declined" | "allowed";
 
@@ -14,9 +13,7 @@ export interface InstallDecisionRecord {
 type InstallDecisions = Record<string, InstallDecisionRecord>;
 
 export function getInstallDecisionsPath(): string {
-	const override = contextEnv("LSP_TOOLS_MCP_INSTALL_DECISIONS");
-	if (!override) return join(homedir(), ".codex", "lsp-install-decisions.json");
-	return isAbsolute(override) ? override : join(homedir(), override);
+	return lspRequestContext().installDecisionsPath;
 }
 
 export function loadInstallDecisions(): InstallDecisions {

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";
+}