oh-my-opencode 4.18.0 → 4.18.2

package/packages/lsp-core/src/lsp/client-diagnostics-freshness.integration.test.ts

@@ -0,0 +1,261 @@
+import { writeFileSync } from "node:fs";
+
+import { afterEach, describe, expect, it } from "bun:test";
+
+import {
+	createWorkspaceEditTestHarness,
+	diagnostic,
+	readEvents,
+	waitForEventCount,
+} from "./workspace-apply-edit-test-support.js";
+
+const harness = createWorkspaceEditTestHarness();
+
+afterEach(async () => {
+	await harness.cleanup();
+});
+
+describe("LspClient diagnostics freshness", () => {
+	it("#given concurrent diagnostics on a cold file and an exact didOpen publish #when pull is not advertised #then one didOpen opens the file and both requests receive the current diagnostics", async () => {
+		const context = await harness.makeClient(
+			{
+				publishDiagnostics: [
+					{
+						trigger: "didOpen",
+						version: 1,
+						diagnostics: [diagnostic("exact-current")],
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+		);
+
+		const [first, second] = await Promise.all([
+			context.client.diagnostics(context.source),
+			context.client.diagnostics(context.source),
+		]);
+
+		expect(first.items).toEqual([diagnostic("exact-current")]);
+		expect(second.items).toEqual([diagnostic("exact-current")]);
+		expect(
+			readEvents(context.events).filter(
+				(event) => event.type === "clientNotification" && event.method === "textDocument/didOpen",
+			),
+		).toHaveLength(1);
+	});
+
+	it("#given a versionless publish that arrives after the current change #when no newer eligible publish arrives before quiescence #then diagnostics wait for that quiescence window and return the versionless payload", async () => {
+		const context = await harness.makeClient(
+			{
+				publishDiagnostics: [
+					{
+						trigger: "didChange",
+						diagnostics: [diagnostic("post-generation-versionless")],
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 80, versionlessPublishQuiescenceMs: 20 },
+		);
+		await context.client.openFile(context.source);
+		await waitForEventCount(
+			context.events,
+			(event) => event.type === "serverNotification" && event.method === "textDocument/publishDiagnostics",
+			1,
+		);
+		writeFileSync(context.source, "const after = 1;\n", "utf-8");
+		await context.client.openFile(context.source);
+
+		const startedAt = Date.now();
+		const result = await context.client.diagnostics(context.source);
+		const elapsedMs = Date.now() - startedAt;
+
+		expect(result.items).toEqual([diagnostic("post-generation-versionless")]);
+		expect(elapsedMs).toBeGreaterThanOrEqual(15);
+	});
+
+	it("#given only a pre-generation versionless publish #when a newer local version asks for diagnostics #then the stale versionless publish is ignored and the request does not resolve clean", async () => {
+		const context = await harness.makeClient(
+			{
+				publishDiagnostics: [
+					{
+						trigger: "didOpen",
+						diagnostics: [diagnostic("pre-generation-versionless")],
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 300, versionlessPublishQuiescenceMs: 5 },
+		);
+		await context.client.openFile(context.source);
+		expect((await context.client.diagnostics(context.source)).items).toEqual([diagnostic("pre-generation-versionless")]);
+		writeFileSync(context.source, "const after = 1;\n", "utf-8");
+		await context.client.openFile(context.source);
+
+		const result = await context.client.diagnostics(context.source);
+
+		expect(result.items).toEqual([]);
+		expect(result.transientError?.kind).toBe("freshness_timeout");
+	});
+
+	it("#given stale and future publish versions #when diagnostics target the current version #then neither stale nor future diagnostics satisfy the request", async () => {
+		const stale = await harness.makeClient(
+			{
+				publishDiagnostics: [
+					{
+						trigger: "didChange",
+						version: 1,
+						diagnostics: [diagnostic("stale")],
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 30, versionlessPublishQuiescenceMs: 5 },
+		);
+		await stale.client.openFile(stale.source);
+		writeFileSync(stale.source, "const stale = 1;\n", "utf-8");
+		await stale.client.openFile(stale.source);
+
+		const staleResult = await stale.client.diagnostics(stale.source);
+
+		expect(staleResult.items).toEqual([]);
+		expect(staleResult.transientError?.kind).toBe("freshness_timeout");
+
+		await harness.cleanup();
+
+		const future = await harness.makeClient(
+			{
+				publishDiagnostics: [
+					{
+						trigger: "didChange",
+						version: 3,
+						diagnostics: [diagnostic("future")],
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 30, versionlessPublishQuiescenceMs: 5 },
+		);
+		await future.client.openFile(future.source);
+		writeFileSync(future.source, "const future = 1;\n", "utf-8");
+		await future.client.openFile(future.source);
+
+		const futureResult = await future.client.diagnostics(future.source);
+
+		expect(futureResult.items).toEqual([]);
+		expect(futureResult.transientError?.kind).toBe("freshness_timeout");
+	});
+
+	it("#given a pull response overtaken by a later local change #when the stale full report returns first #then diagnostics restart within the same request and resolve from the current version", async () => {
+		const context = await harness.makeClient(
+			{
+				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+				diagnosticResponses: [
+					{
+						delayMs: 200,
+						report: { kind: "full", resultId: "v1", items: [diagnostic("pull-stale")] },
+					},
+					{
+						report: { kind: "full", resultId: "v2", items: [diagnostic("pull-fresh")] },
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 800, versionlessPublishQuiescenceMs: 5 },
+		);
+		await context.client.openFile(context.source);
+
+		const pending = context.client.diagnostics(context.source);
+		await waitForEventCount(
+			context.events,
+			(event) => event.type === "clientRequest" && event.method === "textDocument/diagnostic",
+			1,
+		);
+		writeFileSync(context.source, "const pull_fresh = 1;\n", "utf-8");
+		await context.client.openFile(context.source);
+
+		const result = await pending;
+
+		expect(result.items).toEqual([diagnostic("pull-fresh")]);
+		expect(
+			readEvents(context.events).filter(
+				(event) => event.type === "clientRequest" && event.method === "textDocument/diagnostic",
+			),
+		).toHaveLength(2);
+	});
+
+	it("#given a full pull report followed by an unchanged report for the same version and resultId #when diagnostics repeat without a local change #then the cached full items are reused", async () => {
+		const context = await harness.makeClient(
+			{
+				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+				diagnosticResponses: [
+					{
+						report: { kind: "full", resultId: "same-version", items: [diagnostic("cached-full")] },
+					},
+					{
+						report: { kind: "unchanged", resultId: "same-version" },
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5 },
+		);
+		await context.client.openFile(context.source);
+
+		const first = await context.client.diagnostics(context.source);
+		const second = await context.client.diagnostics(context.source);
+
+		expect(first.items).toEqual([diagnostic("cached-full")]);
+		expect(second.items).toEqual([diagnostic("cached-full")]);
+	});
+
+	it("#given a server that claims pull support but closes instead of answering #when diagnostics run #then the transport failure is not labeled clean", async () => {
+		const context = await harness.makeClient(
+			{
+				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+				diagnosticResponses: [{ action: "close" }],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5 },
+		);
+		await context.client.openFile(context.source);
+
+		await expect(context.client.diagnostics(context.source)).rejects.toThrow(/exited|closed/i);
+	});
+
+	it("#given an advertised pull method that is explicitly unsupported and a matching push publish #when diagnostics run #then the client falls back to push diagnostics", async () => {
+		const context = await harness.makeClient(
+			{
+				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+				publishDiagnostics: [
+					{
+						trigger: "didOpen",
+						version: 1,
+						diagnostics: [diagnostic("push-fallback")],
+					},
+				],
+				diagnosticResponses: [{ error: { code: -32601, message: "Method not found" } }],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5 },
+		);
+
+		const result = await context.client.diagnostics(context.source);
+
+		expect(result.items).toEqual([diagnostic("push-fallback")]);
+	});
+
+	it("#given a diagnostic pull request times out #when the fake server keeps it pending #then the client sends cancel for the LSP request id", async () => {
+		const context = await harness.makeClient(
+			{
+				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+				diagnosticResponses: [{ action: "hang" }],
+			},
+			{ requestTimeoutMs: 30, diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+		);
+
+		const result = await context.client.diagnostics(context.source);
+		const [cancel] = await waitForEventCount(
+			context.events,
+			(event) => event.type === "clientNotification" && event.method === "$/cancelRequest",
+			1,
+		);
+		const events = readEvents(context.events);
+		const request = events.find((event) => event.type === "clientRequest" && event.method === "textDocument/diagnostic");
+
+		expect(result.transientError?.kind).toBe("freshness_timeout");
+		expect(cancel?.params).toEqual({ id: request?.id });
+	});
+});

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;