oh-my-opencode 4.18.0 → 4.18.1

package/packages/lsp-core/src/lsp/workspace-apply-edit-test-support.ts

@@ -0,0 +1,163 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import { LspClient } from "./client.js";
+import { LspClientConnection } from "./connection.js";
+import type { LspClientOptions } from "./client.js";
+import type { LspClientTransport } from "./transport.js";
+import type { Diagnostic, ResolvedServer, WorkspaceEdit } from "./types.js";
+
+const fixturePath = join(dirname(fileURLToPath(import.meta.url)), "fixtures", "workspace-edit-server.mjs");
+
+export interface RecordedEvent {
+	readonly type: string;
+	readonly id?: string | number;
+	readonly method?: string;
+	readonly params?: unknown;
+	readonly result?: unknown;
+	readonly error?: unknown;
+}
+
+export interface WorkspaceEditTestContext {
+	readonly client: LspClient;
+	readonly workspace: string;
+	readonly source: string;
+	readonly destination: string;
+	readonly closed: string;
+	readonly created: string;
+	readonly events: string;
+}
+
+export function createWorkspaceEditTestHarness() {
+	const tempDirectories: string[] = [];
+	const clients: LspClientTransport[] = [];
+
+	return {
+		async cleanup(): Promise<void> {
+			for (const client of clients.splice(0)) await client.stop();
+			for (const directory of tempDirectories.splice(0)) rmSync(directory, { recursive: true, force: true });
+		},
+		async makeClient(
+			scenario: Record<string, unknown>,
+			clientOptions: Partial<LspClientOptions> = {},
+		): Promise<WorkspaceEditTestContext> {
+			const fixture = createFixture(scenario, tempDirectories);
+			const client = new LspClient(fixture.workspace, fixture.server, {
+				requestTimeoutMs: 5_000,
+				initializeTimeoutMs: 5_000,
+				...clientOptions,
+			});
+			clients.push(client);
+			await client.start();
+			await client.initialize();
+			return { client, ...fixture.paths };
+		},
+		async makeBareConnection(
+			scenario: Record<string, unknown>,
+		): Promise<{ readonly connection: LspClientConnection; readonly events: string }> {
+			const fixture = createFixture(scenario, tempDirectories);
+			const connection = new LspClientConnection(fixture.workspace, fixture.server, {
+				requestTimeoutMs: 5_000,
+				initializeTimeoutMs: 5_000,
+			});
+			clients.push(connection);
+			await connection.start();
+			await connection.initialize();
+			return { connection, events: fixture.paths.events };
+		},
+	};
+}
+
+function createFixture(scenario: Record<string, unknown>, tempDirectories: string[]) {
+	const workspace = mkdtempSync(join(tmpdir(), "lsp-apply-edit-"));
+	tempDirectories.push(workspace);
+	const source = join(workspace, "source.ts");
+	const destination = join(workspace, "destination.ts");
+	const closed = join(workspace, "closed.ts");
+	const created = join(workspace, "created.ts");
+	const scenarioPath = join(workspace, "scenario.json");
+	const events = join(workspace, "events.jsonl");
+	writeFileSync(source, "const before = 1;\n", "utf-8");
+	writeFileSync(closed, "const closed = 1;\n", "utf-8");
+	const uriByPlaceholder = new Map([
+		["file:///placeholder", pathToFileURL(source).href],
+		["file:///destination", pathToFileURL(destination).href],
+		["file:///closed", pathToFileURL(closed).href],
+		["file:///created", pathToFileURL(created).href],
+	]);
+	writeFileSync(scenarioPath, JSON.stringify(replacePlaceholderUris(scenario, uriByPlaceholder)), "utf-8");
+	writeFileSync(events, "", "utf-8");
+	const server: ResolvedServer = {
+		id: "workspace-edit-fixture",
+		command: [process.env["NODE_BINARY"] ?? "node", fixturePath, scenarioPath, events],
+		extensions: [".ts"],
+		priority: 0,
+	};
+	return { workspace, server, paths: { workspace, source, destination, closed, created, events } };
+}
+
+function replacePlaceholderUris(value: unknown, uriByPlaceholder: ReadonlyMap<string, string>): unknown {
+	if (Array.isArray(value)) return value.map((item) => replacePlaceholderUris(item, uriByPlaceholder));
+	if (typeof value !== "object" || value === null) {
+		return typeof value === "string" ? (uriByPlaceholder.get(value) ?? value) : value;
+	}
+	return Object.fromEntries(
+		Object.entries(value).map(([key, item]) => [key, replacePlaceholderUris(item, uriByPlaceholder)]),
+	);
+}
+
+interface RenameTextEditTarget {
+	readonly version: number | null;
+	readonly uri?: string;
+}
+
+export function renameTextEdit(before: string, after: string, target: RenameTextEditTarget): WorkspaceEdit {
+	const uri = target.uri ?? "file:///placeholder";
+	return {
+		documentChanges: [
+			{
+				textDocument: { uri, version: target.version },
+				edits: [
+					{
+						range: { start: { line: 0, character: 6 }, end: { line: 0, character: 6 + before.length } },
+						newText: after,
+					},
+				],
+			},
+		],
+	};
+}
+
+export function diagnostic(message: string): Diagnostic {
+	return { range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } }, message };
+}
+
+export function readEvents(path: string): readonly RecordedEvent[] {
+	const events: RecordedEvent[] = [];
+	for (const line of readFileSync(path, "utf-8").split("\n")) {
+		if (!line) continue;
+		const value: unknown = JSON.parse(line);
+		if (isRecordedEvent(value)) events.push(value);
+	}
+	return events;
+}
+
+export async function waitForEventCount(
+	path: string,
+	predicate: (event: RecordedEvent) => boolean,
+	count: number,
+): Promise<readonly RecordedEvent[]> {
+	const deadline = Date.now() + 2_000;
+	while (Date.now() < deadline) {
+		const matches = readEvents(path).filter(predicate);
+		if (matches.length >= count) return matches;
+		await new Promise((resolve) => setTimeout(resolve, 10));
+	}
+	return readEvents(path).filter(predicate);
+}
+
+function isRecordedEvent(value: unknown): value is RecordedEvent {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}

package/packages/lsp-core/src/lsp/workspace-apply-edit.integration.test.ts

@@ -0,0 +1,163 @@
+import { readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+
+import { afterEach, describe, expect, it } from "bun:test";
+
+import {
+	createWorkspaceEditTestHarness,
+	diagnostic,
+	readEvents,
+	renameTextEdit,
+} from "./workspace-apply-edit-test-support.js";
+
+const harness = createWorkspaceEditTestHarness();
+
+afterEach(async () => {
+	await harness.cleanup();
+});
+
+describe("LspClient workspace/applyEdit", () => {
+	it("#given a server-applied edit returned again by rename #when rename completes #then one write is reused truthfully", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 1 }), renameResult: "same" }],
+			diagnostics: [diagnostic("fresh")],
+		});
+		let writes = 0;
+		context.client.setWorkspaceEditIo({
+			writeFile(path, content) {
+				writes += 1;
+				writeFileSync(path, content, "utf-8");
+			},
+		});
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.apply.success).toBe(true);
+		expect(result.apply.totalEdits).toBe(1);
+		expect(writes).toBe(1);
+		expect(readFileSync(context.source, "utf-8")).toBe("const after = 1;\n");
+		expect(context.client.getOpenDocumentVersion(context.source)).toBe(2);
+		expect(context.client.getStoredDiagnostics(pathToFileURL(realpathSync(context.source)).href)).toEqual([
+			diagnostic("fresh"),
+		]);
+		const responses = readEvents(context.events).filter(
+			(event) => event.type === "clientResponse" && event.method === "workspace/applyEdit",
+		);
+		expect(responses).toHaveLength(1);
+		expect(responses[0]?.result).toEqual({ applied: true });
+	});
+
+	it("#given a server-applied edit and a null rename result #when rename completes #then the recorded result is reused", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 1 }), renameResult: "null" }],
+		});
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.edit).toBeNull();
+		expect(result.apply.success).toBe(true);
+		expect(readFileSync(context.source, "utf-8")).toBe("const after = 1;\n");
+	});
+
+	it("#given two versioned server edits #when applied sequentially #then the synchronized version accepts the second edit", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [
+				{ applyEdit: renameTextEdit("before", "first_", { version: 1 }), renameResult: "same" },
+				{ applyEdit: renameTextEdit("first_", "second", { version: 2 }), renameResult: "same" },
+			],
+		});
+		await context.client.openFile(context.source);
+
+		const first = await context.client.rename(context.source, 1, 6, "first_");
+		const second = await context.client.rename(context.source, 1, 6, "second");
+
+		expect(first.apply.success).toBe(true);
+		expect(second.apply.success).toBe(true);
+		expect(context.client.getOpenDocumentVersion(context.source)).toBe(3);
+		expect(readFileSync(context.source, "utf-8")).toBe("const second = 1;\n");
+	});
+
+	it("#given a mismatched document version #when the server requests applyEdit #then mutation is rejected truthfully", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 9 }), renameResult: "same" }],
+		});
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.apply.success).toBe(false);
+		expect(result.apply.errors.join("\n")).toContain("document version");
+		expect(readFileSync(context.source, "utf-8")).toBe("const before = 1;\n");
+		const response = readEvents(context.events).find(
+			(event) => event.type === "clientResponse" && event.method === "workspace/applyEdit",
+		);
+		expect(response?.result).toEqual({
+			applied: false,
+			failureReason: expect.stringContaining("document version"),
+			failedChange: 0,
+		});
+	});
+
+	it("#given a server-applied edit and a different rename result #when rename completes #then conflict is reported without a second mutation", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [
+				{
+					applyEdit: renameTextEdit("before", "after", { version: 1 }),
+					renameResult: "different",
+					differentEdit: renameTextEdit("before", "other_", { version: 1 }),
+				},
+			],
+		});
+		let writes = 0;
+		context.client.setWorkspaceEditIo({
+			writeFile(path, content) {
+				writes += 1;
+				writeFileSync(path, content, "utf-8");
+			},
+		});
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.apply.success).toBe(false);
+		expect(result.apply.errors.join("\n")).toContain("conflicts with server-applied workspace edit");
+		expect(writes).toBe(1);
+		expect(readFileSync(context.source, "utf-8")).toBe("const after = 1;\n");
+	});
+
+	it("#given a real commit I/O failure #when the server requests applyEdit #then both protocol and rename result report failure", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 1 }), renameResult: "same" }],
+		});
+		context.client.setWorkspaceEditIo({
+			writeFile() {
+				throw new InjectedWorkspaceIoError();
+			},
+		});
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.apply.success).toBe(false);
+		expect(result.apply.errors.join("\n")).toContain("I/O failure during text");
+		expect(readFileSync(context.source, "utf-8")).toBe("const before = 1;\n");
+		const response = readEvents(context.events).find(
+			(event) => event.type === "clientResponse" && event.method === "workspace/applyEdit",
+		);
+		expect(response?.result).toEqual({
+			applied: false,
+			failureReason: expect.stringContaining("I/O failure during text"),
+			failedChange: 0,
+		});
+	});
+});
+
+class InjectedWorkspaceIoError extends Error {
+	override readonly name = "InjectedWorkspaceIoError";
+
+	constructor() {
+		super("injected workspace I/O failure");
+	}
+}

package/packages/lsp-core/src/lsp/workspace-document-state.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "bun:test";
+
+import { WorkspaceDocumentState } from "./workspace-document-state.js";
+import type { WorkspaceMutation } from "./workspace-edit.js";
+
+describe("WorkspaceDocumentState watched-file bounds", () => {
+	it("#given more closed-file mutations than one batch #when synchronized #then every notification stays bounded", async () => {
+		const notifications: unknown[] = [];
+		const documents = new WorkspaceDocumentState(
+			async (method, params) => {
+				if (method === "workspace/didChangeWatchedFiles") notifications.push(params);
+			},
+			() => {},
+			{ versionlessPublishQuiescenceMs: 0 },
+		);
+		const changedPaths = Array.from({ length: 129 }, (_, index) => `/workspace/file-${index}.ts`);
+		const operations: WorkspaceMutation[] = changedPaths.map((path) => ({
+			kind: "create",
+			path,
+			replaced: false,
+		}));
+
+		await documents.synchronize({ operations, changedPaths });
+
+		expect(notifications).toHaveLength(2);
+		expect(notificationChanges(notifications[0])).toHaveLength(128);
+		expect(notificationChanges(notifications[1])).toHaveLength(1);
+	});
+
+	it("#given changed closed files #when synchronized #then sends bounded changed watched-file notifications", async () => {
+		const notifications: unknown[] = [];
+		const documents = new WorkspaceDocumentState(
+			async (method, params) => {
+				if (method === "workspace/didChangeWatchedFiles") notifications.push(params);
+			},
+			() => {},
+			{ versionlessPublishQuiescenceMs: 0 },
+		);
+		const changedPaths = Array.from({ length: 129 }, (_, index) => `/workspace/file-${index}.ts`);
+		const operations: WorkspaceMutation[] = changedPaths.map((path) => ({
+			kind: "text",
+			path,
+			beforeText: "before",
+			afterText: "after",
+		}));
+
+		await documents.synchronize({ operations, changedPaths });
+
+		expect(notifications).toHaveLength(2);
+		expect(notificationChanges(notifications[0])).toHaveLength(128);
+		expect(notificationChanges(notifications[1])).toHaveLength(1);
+		expect(notificationTypes(notifications[0])).toEqual(Array.from({ length: 128 }, () => 2));
+		expect(notificationTypes(notifications[1])).toEqual([2]);
+	});
+});
+
+function notificationChanges(value: unknown): readonly unknown[] {
+	if (typeof value !== "object" || value === null || !("changes" in value) || !Array.isArray(value.changes)) return [];
+	return value.changes;
+}
+
+function notificationTypes(value: unknown): readonly unknown[] {
+	return notificationChanges(value).map((change) => {
+		if (typeof change !== "object" || change === null || !("type" in change)) return undefined;
+		return change.type;
+	});
+}