oh-my-opencode 4.18.0 → 4.18.2

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

@@ -0,0 +1,368 @@
+import { readFileSync, realpathSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { effectiveExtension } from "./effective-extension.js";
+import { getLanguageId } from "./language-mappings.js";
+import type { Diagnostic } from "./types.js";
+import type { PlannedWorkspaceOperation, WorkspaceMutation, WorkspaceMutationDelta } from "./workspace-edit-types.js";
+
+const WATCHED_FILE_BATCH_SIZE = 128;
+const DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS = 250;
+
+type SendNotification = (method: string, params: unknown) => Promise<void>;
+
+interface OpenDocumentState {
+	readonly path: string;
+	readonly uri: string;
+	readonly languageId: string;
+	text: string;
+	version: number;
+	generation: number;
+	publishGeneration: number;
+	lastPublish?: PublishedDiagnostics;
+	pullCache?: PullDiagnosticsCache;
+	waiters: Set<() => void>;
+}
+
+interface WatchedFileEvent {
+	readonly uri: string;
+	readonly type: 1 | 2 | 3;
+}
+
+interface PublishedDiagnostics {
+	readonly diagnostics: readonly Diagnostic[];
+	readonly publishGeneration: number;
+	readonly documentGenerationAtArrival: number;
+	readonly arrivedAt: number;
+	readonly version?: number;
+}
+
+interface PullDiagnosticsCache {
+	readonly documentVersion: number;
+	readonly diagnostics: readonly Diagnostic[];
+	readonly resultId?: string;
+}
+
+export interface DocumentVersionFailure {
+	readonly changeIndex: number;
+	readonly message: string;
+}
+
+export interface DiagnosticSnapshot {
+	readonly path: string;
+	readonly uri: string;
+	readonly version: number;
+	readonly documentGeneration: number;
+	readonly publishGeneration: number;
+}
+
+export interface PullDiagnosticsReport {
+	readonly diagnostics: readonly Diagnostic[];
+	readonly kind: "full";
+	readonly resultId?: string;
+}
+
+export interface PullDiagnosticsCacheHit {
+	readonly documentVersion: number;
+	readonly diagnostics: readonly Diagnostic[];
+	readonly resultId?: string;
+}
+
+export type PushDiagnosticsResolution =
+	| { readonly status: "ready"; readonly diagnostics: readonly Diagnostic[] }
+	| { readonly status: "wait"; readonly waitMs: number }
+	| { readonly status: "missing" };
+
+export interface WorkspaceDocumentStateOptions {
+	readonly now?: () => number;
+	readonly versionlessPublishQuiescenceMs?: number;
+}
+
+function canonicalPath(filePath: string): string {
+	const absolute = resolve(filePath);
+	try {
+		return realpathSync(absolute);
+	} catch {
+		return absolute;
+	}
+}
+
+function isSameOrDescendant(candidate: string, parent: string): boolean {
+	const suffix = relative(parent, candidate);
+	return suffix === "" || (!suffix.startsWith("..") && suffix !== "..");
+}
+
+function movedPath(candidate: string, oldPath: string, newPath: string): string {
+	const suffix = relative(oldPath, candidate);
+	return suffix === "" ? newPath : resolve(newPath, suffix);
+}
+
+export class WorkspaceDocumentState {
+	private readonly openDocuments = new Map<string, OpenDocumentState>();
+	private readonly openByUri = new Map<string, OpenDocumentState>();
+	private readonly openPromises = new Map<string, Promise<void>>();
+	private readonly now: () => number;
+	private readonly versionlessPublishQuiescenceMs: number;
+
+	constructor(
+		private readonly sendNotification: SendNotification,
+		private readonly clearDiagnostics: (uri: string) => void,
+		options: WorkspaceDocumentStateOptions = {},
+	) {
+		this.now = options.now ?? (() => Date.now());
+		this.versionlessPublishQuiescenceMs =
+			options.versionlessPublishQuiescenceMs ?? DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS;
+	}
+
+	async openFile(filePath: string): Promise<void> {
+		const path = canonicalPath(filePath);
+		const existingOpen = this.openPromises.get(path);
+		if (existingOpen) {
+			await existingOpen;
+			return this.openFile(path);
+		}
+
+		const text = readFileSync(path, "utf-8");
+		const existing = this.openDocuments.get(path);
+		if (!existing) return this.openDocumentSingleFlight(path, text);
+		if (existing.text === text) return;
+		await this.changeDocument(existing, text);
+	}
+
+	getVersion(filePath: string): number | undefined {
+		return this.openDocuments.get(canonicalPath(filePath))?.version;
+	}
+
+	getStoredDiagnostics(uri: string): readonly Diagnostic[] {
+		const state = this.openByUri.get(uri);
+		if (!state) return [];
+		return state.lastPublish?.diagnostics ?? state.pullCache?.diagnostics ?? [];
+	}
+
+	captureDiagnosticSnapshot(filePath: string): DiagnosticSnapshot | null {
+		const state = this.openDocuments.get(canonicalPath(filePath));
+		if (!state) return null;
+		return {
+			path: state.path,
+			uri: state.uri,
+			version: state.version,
+			documentGeneration: state.generation,
+			publishGeneration: state.publishGeneration,
+		};
+	}
+
+	isCurrentSnapshot(snapshot: DiagnosticSnapshot): boolean {
+		const state = this.openDocuments.get(snapshot.path);
+		return (
+			state !== undefined &&
+			state.uri === snapshot.uri &&
+			state.version === snapshot.version &&
+			state.generation === snapshot.documentGeneration
+		);
+	}
+
+	getPullCache(snapshot: DiagnosticSnapshot): PullDiagnosticsCacheHit | null {
+		const state = this.openByUri.get(snapshot.uri);
+		if (!state?.pullCache || state.pullCache.documentVersion !== snapshot.version) return null;
+		return state.pullCache;
+	}
+
+	recordPullDiagnostics(snapshot: DiagnosticSnapshot, report: PullDiagnosticsReport): void {
+		const state = this.openByUri.get(snapshot.uri);
+		if (!state) return;
+		state.pullCache = {
+			documentVersion: snapshot.version,
+			diagnostics: [...report.diagnostics],
+			...(report.resultId === undefined ? {} : { resultId: report.resultId }),
+		};
+	}
+
+	recordPublishedDiagnostics(params: {
+		readonly uri: string;
+		readonly diagnostics: readonly Diagnostic[];
+		readonly version?: number;
+	}): void {
+		const state = this.openByUri.get(params.uri);
+		if (!state) return;
+		state.publishGeneration += 1;
+		state.lastPublish = {
+			diagnostics: [...params.diagnostics],
+			publishGeneration: state.publishGeneration,
+			documentGenerationAtArrival: state.generation,
+			arrivedAt: this.now(),
+			...(params.version === undefined ? {} : { version: params.version }),
+		};
+		this.notifyWaiters(state);
+	}
+
+	resolvePushDiagnostics(snapshot: DiagnosticSnapshot): PushDiagnosticsResolution {
+		const state = this.openByUri.get(snapshot.uri);
+		if (!state?.lastPublish) return { status: "missing" };
+		const publish = state.lastPublish;
+		if (publish.version !== undefined) {
+			return publish.version === snapshot.version
+				? { status: "ready", diagnostics: publish.diagnostics }
+				: { status: "missing" };
+		}
+		if (publish.documentGenerationAtArrival < snapshot.documentGeneration) return { status: "missing" };
+		const readyAt = publish.arrivedAt + this.versionlessPublishQuiescenceMs;
+		const waitMs = Math.max(0, readyAt - this.now());
+		return waitMs === 0
+			? { status: "ready", diagnostics: publish.diagnostics }
+			: { status: "wait", waitMs };
+	}
+
+	waitForDiagnosticsActivity(snapshot: DiagnosticSnapshot, timeoutMs: number): Promise<void> {
+		const state = this.openByUri.get(snapshot.uri);
+		if (!state || timeoutMs <= 0) return Promise.resolve();
+		return new Promise((resolveActivity) => {
+			let settled = false;
+			const finish = () => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				state.waiters.delete(finish);
+				resolveActivity();
+			};
+			const timer = setTimeout(finish, timeoutMs);
+			if (typeof timer.unref === "function") timer.unref();
+			state.waiters.add(finish);
+		});
+	}
+
+	validateVersions(operations: readonly PlannedWorkspaceOperation[]): DocumentVersionFailure | null {
+		const versions = new Map([...this.openDocuments].map(([path, state]) => [path, state.version]));
+		for (const operation of operations) {
+			if (operation.kind === "text") {
+				const current = versions.get(operation.path);
+				if (operation.documentVersion !== null && current !== operation.documentVersion) {
+					const observed = current === undefined ? "closed document" : `open document version ${current}`;
+					return {
+						changeIndex: operation.changeIndex,
+						message: `document version ${operation.documentVersion} does not match ${observed} for ${operation.path}`,
+					};
+				}
+				if (current !== undefined) versions.set(operation.path, current + 1);
+				continue;
+			}
+			if (operation.kind === "rename") {
+				const moved = [...versions].filter(([path]) => isSameOrDescendant(path, operation.oldPath));
+				for (const [path] of moved) versions.delete(path);
+				for (const [path] of moved) versions.set(movedPath(path, operation.oldPath, operation.newPath), 1);
+				continue;
+			}
+			if (operation.kind === "delete") {
+				for (const path of [...versions.keys()]) {
+					if (isSameOrDescendant(path, operation.path)) versions.delete(path);
+				}
+				continue;
+			}
+			if (operation.kind === "create" && operation.replaced && versions.has(operation.path)) {
+				versions.set(operation.path, 1);
+			}
+		}
+		return null;
+	}
+
+	async synchronize(delta: WorkspaceMutationDelta): Promise<void> {
+		const watched: WatchedFileEvent[] = [];
+		for (const mutation of delta.operations) await this.synchronizeMutation(mutation, watched);
+		for (let index = 0; index < watched.length; index += WATCHED_FILE_BATCH_SIZE) {
+			await this.sendNotification("workspace/didChangeWatchedFiles", {
+				changes: watched.slice(index, index + WATCHED_FILE_BATCH_SIZE),
+			});
+		}
+	}
+
+	private async synchronizeMutation(mutation: WorkspaceMutation, watched: WatchedFileEvent[]): Promise<void> {
+		if (mutation.kind === "text") {
+			const state = this.openDocuments.get(mutation.path);
+			if (state) await this.changeDocument(state, mutation.afterText);
+			else watched.push({ uri: pathToFileURL(mutation.path).href, type: 2 });
+			return;
+		}
+		if (mutation.kind === "create") {
+			const state = this.openDocuments.get(mutation.path);
+			if (state) {
+				await this.closeDocument(state);
+				await this.openDocumentSingleFlight(mutation.path, readFileSync(mutation.path, "utf-8"));
+			} else {
+				watched.push({ uri: pathToFileURL(mutation.path).href, type: mutation.replaced ? 2 : 1 });
+			}
+			return;
+		}
+		if (mutation.kind === "rename") {
+			const moved = [...this.openDocuments.values()].filter((state) =>
+				isSameOrDescendant(state.path, mutation.oldPath),
+			);
+			for (const state of moved) await this.closeDocument(state);
+			for (const state of moved) {
+				const path = movedPath(state.path, mutation.oldPath, mutation.newPath);
+				await this.openDocumentSingleFlight(path, readFileSync(path, "utf-8"));
+			}
+			if (moved.length === 0) {
+				watched.push({ uri: pathToFileURL(mutation.oldPath).href, type: 3 });
+				watched.push({ uri: pathToFileURL(mutation.newPath).href, type: 1 });
+			}
+			return;
+		}
+		const removed = [...this.openDocuments.values()].filter((state) =>
+			isSameOrDescendant(state.path, mutation.path),
+		);
+		for (const state of removed) await this.closeDocument(state);
+		if (removed.length === 0) watched.push({ uri: pathToFileURL(mutation.path).href, type: 3 });
+	}
+
+	private async openDocumentSingleFlight(path: string, text: string): Promise<void> {
+		const existing = this.openPromises.get(path);
+		if (existing) return existing;
+		const open = (async () => {
+			const state: OpenDocumentState = {
+				path,
+				uri: pathToFileURL(path).href,
+				languageId: getLanguageId(effectiveExtension(path)),
+				text,
+				version: 1,
+				generation: 1,
+				publishGeneration: 0,
+				waiters: new Set(),
+			};
+			this.openDocuments.set(path, state);
+			this.openByUri.set(state.uri, state);
+			this.notifyWaiters(state);
+			await this.sendNotification("textDocument/didOpen", {
+				textDocument: { uri: state.uri, languageId: state.languageId, version: state.version, text },
+			});
+		})().finally(() => {
+			this.openPromises.delete(path);
+		});
+		this.openPromises.set(path, open);
+		return open;
+	}
+
+	private async changeDocument(state: OpenDocumentState, text: string): Promise<void> {
+		state.text = text;
+		state.version += 1;
+		state.generation += 1;
+		this.clearDiagnostics(state.uri);
+		this.notifyWaiters(state);
+		await this.sendNotification("textDocument/didChange", {
+			textDocument: { uri: state.uri, version: state.version },
+			contentChanges: [{ text }],
+		});
+		await this.sendNotification("textDocument/didSave", { textDocument: { uri: state.uri }, text });
+	}
+
+	private async closeDocument(state: OpenDocumentState): Promise<void> {
+		this.openDocuments.delete(state.path);
+		this.openByUri.delete(state.uri);
+		this.clearDiagnostics(state.uri);
+		this.notifyWaiters(state);
+		await this.sendNotification("textDocument/didClose", { textDocument: { uri: state.uri } });
+	}
+
+	private notifyWaiters(state: OpenDocumentState): void {
+		for (const waiter of [...state.waiters]) waiter();
+	}
+}

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

@@ -0,0 +1,113 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { applyWorkspaceEdit, planWorkspaceEdit } from "./workspace-edit.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) rmSync(directory, { recursive: true, force: true });
+});
+
+describe("workspace edit adversarial inputs", () => {
+	it("#given malformed and decorated URIs #when planned #then every variant is rejected before mutation", () => {
+		const workspace = makeTempDirectory("lsp-workspace-");
+		const source = join(workspace, "source.ts");
+		writeFileSync(source, "const before = 1;\n", "utf-8");
+		const decorated = `${pathToFileURL(source).href}?query=forbidden`;
+
+		for (const uri of ["untitled:source.ts", decorated, "file:///%ZZ"] as const) {
+			const result = planWorkspaceEdit({ changes: { [uri]: [insertion()] } }, workspace);
+			expect(result.success).toBe(false);
+		}
+		expect(readFileSync(source, "utf-8")).toBe("const before = 1;\n");
+	});
+
+	it("#given invalid ranges and resource options #when planned #then each failure retains its operation index", () => {
+		const workspace = makeTempDirectory("lsp-workspace-");
+		const source = join(workspace, "source.ts");
+		const created = join(workspace, "created.ts");
+		writeFileSync(source, "const before = 1;\n", "utf-8");
+		const invalidRange = planWorkspaceEdit(
+			{
+				documentChanges: [
+					{
+						textDocument: { uri: pathToFileURL(source).href, version: null },
+						edits: [
+							{
+								range: { start: { line: 0, character: -1 }, end: { line: 0, character: 2 } },
+								newText: "bad",
+							},
+						],
+					},
+				],
+			},
+			workspace,
+		);
+		const invalidOption = planWorkspaceEdit(
+			{
+				documentChanges: [
+					{
+						textDocument: { uri: pathToFileURL(source).href, version: null },
+						edits: [],
+					},
+					{ kind: "create", uri: pathToFileURL(created).href, options: { overwrite: "yes" } },
+				],
+			},
+			workspace,
+		);
+
+		expect(invalidRange.success).toBe(false);
+		if (!invalidRange.success) expect(invalidRange.result.errors[0]).toContain("change 0");
+		expect(invalidOption.success).toBe(false);
+		if (!invalidOption.success) expect(invalidOption.result.errors[0]).toContain("change 1");
+		expect(readFileSync(source, "utf-8")).toBe("const before = 1;\n");
+	});
+
+	it("#given an outside target and a dirty unrelated file #when prevalidation fails #then neither is touched", () => {
+		const workspace = makeTempDirectory("lsp-workspace-");
+		const outside = makeTempDirectory("lsp-outside-");
+		const dirty = join(workspace, "dirty.ts");
+		const outsideFile = join(outside, "outside.ts");
+		writeFileSync(dirty, "user-owned dirty bytes\n", "utf-8");
+		writeFileSync(outsideFile, "outside bytes\n", "utf-8");
+
+		const result = applyWorkspaceEdit(
+			{ changes: { [pathToFileURL(outsideFile).href]: [insertion()] } },
+			{ workspaceRoot: workspace },
+		);
+
+		expect(result.success).toBe(false);
+		expect(result.errors.join("\n")).toContain("outside workspace");
+		expect(readFileSync(dirty, "utf-8")).toBe("user-owned dirty bytes\n");
+		expect(readFileSync(outsideFile, "utf-8")).toBe("outside bytes\n");
+	});
+
+	it("#given annotations or mixed edit representations #when planned #then unsupported claims are rejected", () => {
+		const workspace = makeTempDirectory("lsp-workspace-");
+		const unsupported = [
+			{ changeAnnotations: { change: { label: "unsupported" } } },
+			{ changes: {}, documentChanges: [] },
+			{ documentChanges: [{ kind: "create", uri: "file:///missing", annotationId: "change" }] },
+		];
+
+		for (const edit of unsupported) expect(planWorkspaceEdit(edit, workspace).success).toBe(false);
+	});
+});
+
+function insertion() {
+	return {
+		range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
+		newText: "x",
+	};
+}
+
+function makeTempDirectory(prefix: string): string {
+	const directory = mkdtempSync(join(tmpdir(), prefix));
+	tempDirectories.push(directory);
+	return directory;
+}

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

@@ -0,0 +1,140 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { applyWorkspaceEditDetailed, commitWorkspaceEditPlan, planWorkspaceEdit } from "./workspace-edit.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) rmSync(directory, { recursive: true, force: true });
+});
+
+describe("workspace edit commit barrier", () => {
+	it("#given cancellation before commit #when a valid plan is applied #then no mutation begins", () => {
+		const fixture = makeFixture();
+		const controller = new AbortController();
+		controller.abort();
+
+		const commit = applyWorkspaceEditDetailed(textEdit(fixture.source, "before", "after"), {
+			workspaceRoot: fixture.workspace,
+			signal: controller.signal,
+		});
+
+		expect(commit.result.success).toBe(false);
+		expect(commit.result.errors.join("\n")).toContain("cancelled before commit");
+		expect(commit.delta.operations).toEqual([]);
+		expect(readFileSync(fixture.source, "utf-8")).toBe("const before = 1;\n");
+	});
+
+	it("#given repeated pre-gate interruptions #when retried #then every attempt leaves the snapshot untouched", () => {
+		const fixture = makeFixture();
+		for (let attempt = 0; attempt < 3; attempt += 1) {
+			const controller = new AbortController();
+			controller.abort();
+			const commit = applyWorkspaceEditDetailed(textEdit(fixture.source, "before", "after"), {
+				workspaceRoot: fixture.workspace,
+				signal: controller.signal,
+			});
+			expect(commit.result.success).toBe(false);
+			expect(commit.delta.operations).toEqual([]);
+		}
+		expect(readFileSync(fixture.source, "utf-8")).toBe("const before = 1;\n");
+	});
+
+	it("#given cancellation after the first write #when commit has crossed the barrier #then all operations finish once", () => {
+		const fixture = makeFixture();
+		const second = join(fixture.workspace, "second.ts");
+		writeFileSync(second, "const second = 2;\n", "utf-8");
+		const controller = new AbortController();
+		let writes = 0;
+
+		const commit = applyWorkspaceEditDetailed(
+			{
+				changes: {
+					[pathToFileURL(fixture.source).href]: [replacement("before", "after")],
+					[pathToFileURL(second).href]: [replacement("second", "later_")],
+				},
+			},
+			{
+				workspaceRoot: fixture.workspace,
+				signal: controller.signal,
+				io: {
+					writeFile(path, content) {
+						writes += 1;
+						writeFileSync(path, content, "utf-8");
+						if (writes === 1) controller.abort();
+					},
+				},
+			},
+		);
+
+		expect(commit.result).toMatchObject({ success: true, lateAbort: true, totalEdits: 2 });
+		expect(writes).toBe(2);
+		expect(readFileSync(fixture.source, "utf-8")).toBe("const after = 1;\n");
+		expect(readFileSync(second, "utf-8")).toBe("const later_ = 2;\n");
+	});
+
+	it("#given an injected write failure #when commit begins #then the result reports real I/O failure", () => {
+		const fixture = makeFixture();
+
+		const commit = applyWorkspaceEditDetailed(textEdit(fixture.source, "before", "after"), {
+			workspaceRoot: fixture.workspace,
+			io: {
+				writeFile() {
+					throw new InjectedWriteError();
+				},
+			},
+		});
+
+		expect(commit.result).toMatchObject({ success: false, failedChange: 0 });
+		expect(commit.result.errors.join("\n")).toContain("I/O failure during text: injected write failure");
+		expect(commit.delta.operations).toEqual([]);
+		expect(readFileSync(fixture.source, "utf-8")).toBe("const before = 1;\n");
+	});
+
+	it("#given a stale file snapshot #when a prepared plan commits #then the newer bytes are preserved", () => {
+		const fixture = makeFixture();
+		const planned = planWorkspaceEdit(textEdit(fixture.source, "before", "after"), fixture.workspace);
+		expect(planned.success).toBe(true);
+		if (!planned.success) return;
+		writeFileSync(fixture.source, "const external = 2;\n", "utf-8");
+
+		const commit = commitWorkspaceEditPlan(planned.plan);
+
+		expect(commit.result.success).toBe(false);
+		expect(commit.result.errors.join("\n")).toContain("workspace state changed before commit");
+		expect(commit.delta.operations).toEqual([]);
+		expect(readFileSync(fixture.source, "utf-8")).toBe("const external = 2;\n");
+	});
+});
+
+class InjectedWriteError extends Error {
+	override readonly name = "InjectedWriteError";
+
+	constructor() {
+		super("injected write failure");
+	}
+}
+
+function makeFixture(): { readonly workspace: string; readonly source: string } {
+	const workspace = mkdtempSync(join(tmpdir(), "lsp-workspace-commit-"));
+	tempDirectories.push(workspace);
+	const source = join(workspace, "source.ts");
+	writeFileSync(source, "const before = 1;\n", "utf-8");
+	return { workspace, source };
+}
+
+function textEdit(path: string, before: string, after: string) {
+	return { changes: { [pathToFileURL(path).href]: [replacement(before, after)] } };
+}
+
+function replacement(before: string, after: string) {
+	return {
+		range: { start: { line: 0, character: 6 }, end: { line: 0, character: 6 + before.length } },
+		newText: after,
+	};
+}