oh-my-opencode 5.1.51 → 5.1.54

package/packages/lsp-core/src/lsp/host-js-runtime.test.ts

@@ -0,0 +1,150 @@
+import { chmodSync, mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { runWithRequestContext } from "../request-context.js";
+import { withHostJsRuntime } from "./host-js-runtime.js";
+import { __resetServerBinaryResolutionCacheForTests } from "./server-installation.js";
+import { findServerForExtension } from "./server-resolution.js";
+
+const tempDirectories: string[] = [];
+let previousPath: string | undefined;
+const BUN = "/opt/bun/bin/bun";
+
+function makeTempRoot(): string {
+	const root = mkdtempSync(join(tmpdir(), "lsp-host-js-"));
+	tempDirectories.push(root);
+	return root;
+}
+
+function writeFile(path: string, content: string): string {
+	mkdirSync(join(path, ".."), { recursive: true });
+	writeFileSync(path, content);
+	chmodSync(path, 0o755);
+	return path;
+}
+
+function installTypescriptLanguageServer(root: string): { bin: string; cli: string } {
+	writeFileSync(join(root, "package.json"), "{}\n");
+	const cli = writeFile(
+		join(root, "node_modules", "typescript-language-server", "lib", "cli.mjs"),
+		"#!/usr/bin/env node\nexport {};\n",
+	);
+	const bin = join(root, "node_modules", ".bin", "typescript-language-server");
+	mkdirSync(join(bin, ".."), { recursive: true });
+	symlinkSync(join("..", "typescript-language-server", "lib", "cli.mjs"), bin);
+	return { bin, cli: realpathSync(cli) };
+}
+
+beforeEach(() => {
+	previousPath = process.env["PATH"];
+	__resetServerBinaryResolutionCacheForTests();
+});
+
+afterEach(() => {
+	if (previousPath === undefined) delete process.env["PATH"];
+	else process.env["PATH"] = previousPath;
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+	__resetServerBinaryResolutionCacheForTests();
+});
+
+describe("withHostJsRuntime", () => {
+	test("#given a Bun host and the npm bin link of typescript-language-server #then it runs the real script with Bun", () => {
+		const { bin, cli } = installTypescriptLanguageServer(makeTempRoot());
+
+		expect(withHostJsRuntime("typescript", [bin, "--stdio"], { bunExecPath: BUN })).toEqual([
+			BUN,
+			cli,
+			"--stdio",
+		]);
+	});
+
+	test("#given a Node host #then the command is unchanged", () => {
+		const { bin } = installTypescriptLanguageServer(makeTempRoot());
+
+		expect(withHostJsRuntime("typescript", [bin, "--stdio"], { bunExecPath: undefined })).toEqual([bin, "--stdio"]);
+	});
+
+	test("#given another node-based server #then the command is unchanged", () => {
+		const root = makeTempRoot();
+		const eslint = writeFile(join(root, "eslint-ls.js"), "#!/usr/bin/env node\n");
+
+		expect(withHostJsRuntime("eslint", [eslint, "--stdio"], { bunExecPath: BUN })).toEqual([eslint, "--stdio"]);
+	});
+
+	test("#given a typescript command that is a native binary or shell shim #then the command is unchanged", () => {
+		const root = makeTempRoot();
+		const shim = writeFile(join(root, "typescript-language-server"), "#!/bin/sh\nexec node cli.mjs \"$@\"\n");
+
+		expect(withHostJsRuntime("typescript", [shim, "--stdio"], { bunExecPath: BUN })).toEqual([shim, "--stdio"]);
+	});
+});
+
+describe("withHostJsRuntime fallbacks", () => {
+	test("#given a bare command that is not on PATH #then the command is unchanged instead of throwing", () => {
+		expect(withHostJsRuntime("typescript", ["node", "/x/cli.mjs", "--stdio"], { bunExecPath: BUN })).toEqual([
+			"node",
+			"/x/cli.mjs",
+			"--stdio",
+		]);
+	});
+
+	test("#given a resolved path that no longer exists #then the command is unchanged instead of throwing", () => {
+		const missing = join(makeTempRoot(), "gone", "typescript-language-server");
+
+		expect(withHostJsRuntime("typescript", [missing, "--stdio"], { bunExecPath: BUN })).toEqual([missing, "--stdio"]);
+	});
+});
+
+describe("findServerForExtension on a Bun host", () => {
+	test("#given a user typescript entry with its own command #then the command is not moved to Bun", () => {
+		const root = makeTempRoot();
+		const { bin } = installTypescriptLanguageServer(root);
+		process.env["PATH"] = join(root, "definitely-empty");
+		mkdirSync(join(root, "home-config"), { recursive: true });
+		writeFileSync(
+			join(root, "home-config", "lsp-client.json"),
+			JSON.stringify({ lsp: { typescript: { command: [bin, "--stdio"], extensions: [".ts"] } } }),
+		);
+
+		const result = runWithRequestContext(
+			{
+				cwd: root,
+				projectConfigPaths: [join(root, ".codex", "lsp-client.json")],
+				userConfigPath: join(root, "home-config", "lsp-client.json"),
+				installDecisionsPath: join(root, "home-config", "lsp-install-decisions.json"),
+				capabilities: { installDecisionTool: false },
+			},
+			() => findServerForExtension(".ts"),
+		);
+
+		expect(result.status).toBe("found");
+		if (result.status !== "found") throw new Error("expected a found server");
+		expect(result.server.command).toEqual([bin, "--stdio"]);
+	});
+
+	test("#given a repo-local typescript-language-server #when a .ts file is looked up #then the server is spawned by this Bun", () => {
+		const root = makeTempRoot();
+		const { cli } = installTypescriptLanguageServer(root);
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		const result = runWithRequestContext(
+			{
+				cwd: root,
+				projectConfigPaths: [join(root, ".codex", "lsp-client.json")],
+				userConfigPath: join(root, "home-config", "lsp-client.json"),
+				installDecisionsPath: join(root, "home-config", "lsp-install-decisions.json"),
+				capabilities: { installDecisionTool: false },
+			},
+			() => findServerForExtension(".ts"),
+		);
+
+		expect(result.status).toBe("found");
+		if (result.status !== "found") throw new Error("expected a found server");
+		expect(result.server.id).toBe("typescript");
+		expect(result.server.command).toEqual([process.execPath, cli, "--stdio"]);
+	});
+});

package/packages/lsp-core/src/lsp/host-js-runtime.ts

@@ -0,0 +1,57 @@
+import { closeSync, openSync, readSync, realpathSync } from "node:fs";
+
+/**
+ * Servers whose JavaScript entry is proven to run on Bun. typescript-language-server forks
+ * tsserver with `process.execPath`, so starting it with Bun keeps the whole tree on Bun
+ * instead of the `node` its shebang finds on PATH. Other node-based servers are not listed
+ * until they are measured.
+ */
+const HOST_RUNTIME_SERVER_IDS = new Set(["typescript"]);
+const JS_ENTRY = /\.[cm]?js$/;
+const NODE_SHEBANG = /^#![^\n]*\bnode\b/;
+
+export interface HostJsRuntime {
+	readonly bunExecPath: string | undefined;
+}
+
+function currentHostJsRuntime(): HostJsRuntime {
+	return { bunExecPath: process.versions["bun"] === undefined ? undefined : process.execPath };
+}
+
+export function withHostJsRuntime(
+	serverId: string,
+	command: string[],
+	host: HostJsRuntime = currentHostJsRuntime(),
+): string[] {
+	if (host.bunExecPath === undefined || !HOST_RUNTIME_SERVER_IDS.has(serverId)) return command;
+	const [binary, ...args] = command;
+	if (binary === undefined) return command;
+	const script = nodeScriptPath(binary);
+	return script === undefined ? command : [host.bunExecPath, script, ...args];
+}
+
+function nodeScriptPath(binary: string): string | undefined {
+	let real: string;
+	try {
+		real = realpathSync(binary);
+	} catch {
+		return undefined;
+	}
+	if (JS_ENTRY.test(real)) return real;
+	try {
+		return NODE_SHEBANG.test(readHead(real)) ? real : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function readHead(path: string): string {
+	const fd = openSync(path, "r");
+	try {
+		const buffer = Buffer.alloc(128);
+		const bytes = readSync(fd, buffer, 0, buffer.length, 0);
+		return buffer.toString("utf8", 0, bytes);
+	} finally {
+		closeSync(fd);
+	}
+}

package/packages/lsp-core/src/lsp/server-definitions.ts

@@ -78,10 +78,20 @@ export const LSP_LOCAL_INSTALL_HINTS: Record<string, string> = {
 	"ruby-lsp": "bundle add ruby-lsp --group development",
 };
 
+/**
+ * typescript-language-server starts a second, syntax-only tsserver and a typingsInstaller by
+ * default. The LSP tools only use semantic requests, so both are extra processes per session.
+ */
+const TYPESCRIPT_SERVER_INITIALIZATION: Record<string, unknown> = {
+	tsserver: { useSyntaxServer: "never" },
+	disableAutomaticTypingAcquisition: true,
+};
+
 export const BUILTIN_SERVERS: Record<string, Omit<LspServerConfig, "id">> = {
 	typescript: {
 		command: ["typescript-language-server", "--stdio"],
 		extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+		initialization: TYPESCRIPT_SERVER_INITIALIZATION,
 	},
 	deno: { command: ["deno", "lsp"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs"] },
 	vue: { command: ["vue-language-server", "--stdio"], extensions: [".vue"] },

package/packages/lsp-core/src/lsp/server-resolution.ts

@@ -1,5 +1,6 @@
 import { contextCwd } from "../request-context.js";
 import { getDisabledServerIds, getMergedServers } from "./config-loader.js";
+import { withHostJsRuntime } from "./host-js-runtime.js";
 import { BUILTIN_SERVERS, LSP_INSTALL_HINTS } from "./server-definitions.js";
 import { isServerInstalled, resolveServerBinary } from "./server-installation.js";
 import type { ServerLookupResult } from "./types.js";
@@ -12,6 +13,11 @@ function withResolvedCommand(command: string[], binaryPath: string): string[] {
 	return [binaryPath, ...command.slice(1)];
 }
 
+function usesBuiltinCommand(id: string, command: string[]): boolean {
+	const builtin = BUILTIN_SERVERS[id]?.command;
+	return builtin !== undefined && builtin.length === command.length && builtin.every((part, index) => part === command[index]);
+}
+
 export function findServerForExtension(ext: string): ServerLookupResult {
 	const servers = getMergedServers();
 	const workingDirectory = contextCwd();
@@ -22,7 +28,9 @@ export function findServerForExtension(ext: string): ServerLookupResult {
 		if (binaryPath !== null) {
 			const resolvedServer = {
 				id: server.id,
-				command: withResolvedCommand(server.command, binaryPath),
+				command: usesBuiltinCommand(server.id, server.command)
+					? withHostJsRuntime(server.id, withResolvedCommand(server.command, binaryPath))
+					: withResolvedCommand(server.command, binaryPath),
 				extensions: server.extensions,
 				priority: server.priority,
 			};

package/packages/lsp-core/src/lsp/typescript-server-defaults.test.ts

@@ -0,0 +1,84 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { runWithRequestContext, type LspRequestContext } from "../request-context.js";
+import { getMergedServers } from "./config-loader.js";
+import { BUILTIN_SERVERS } from "./server-definitions.js";
+
+const LEAN_TYPESCRIPT_INITIALIZATION = {
+	tsserver: { useSyntaxServer: "never" },
+	disableAutomaticTypingAcquisition: true,
+};
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function contextWithConfigs(configs: { project?: unknown; user?: unknown }): LspRequestContext {
+	const directory = mkdtempSync(join(tmpdir(), "lsp-ts-defaults-"));
+	tempDirectories.push(directory);
+	const projectPath = join(directory, "project-lsp.json");
+	const userPath = join(directory, "user-lsp.json");
+	if (configs.project !== undefined) writeFileSync(projectPath, JSON.stringify(configs.project));
+	if (configs.user !== undefined) writeFileSync(userPath, JSON.stringify(configs.user));
+	return {
+		cwd: directory,
+		projectConfigPaths: [projectPath],
+		userConfigPath: userPath,
+		installDecisionsPath: join(directory, "install-decisions.json"),
+		capabilities: { installDecisionTool: false },
+	};
+}
+
+function mergedTypescript(configs: { project?: unknown; user?: unknown }) {
+	const servers = runWithRequestContext(contextWithConfigs(configs), () => getMergedServers());
+	return servers.find((server) => server.id === "typescript");
+}
+
+describe("TypeScript language server defaults", () => {
+	it("#given the builtin definition #then its default config turns off the syntax server and automatic typings", () => {
+		expect(BUILTIN_SERVERS["typescript"]?.initialization).toEqual(LEAN_TYPESCRIPT_INITIALIZATION);
+	});
+
+	it("#given no config #when merging servers #then the builtin typescript server carries the defaults", () => {
+		expect(mergedTypescript({})?.initialization).toEqual(LEAN_TYPESCRIPT_INITIALIZATION);
+	});
+
+	it("#given a user entry that only changes priority #then the defaults survive", () => {
+		const server = mergedTypescript({ user: { lsp: { typescript: { priority: 5 } } } });
+		expect(server?.source).toBe("user");
+		expect(server?.initialization).toEqual(LEAN_TYPESCRIPT_INITIALIZATION);
+	});
+
+	it("#given a project entry with its own initialization #then its keys win over the defaults", () => {
+		const server = mergedTypescript({
+			project: { lsp: { typescript: { initialization: { tsserver: { useSyntaxServer: "auto" }, hostInfo: "x" } } } },
+		});
+		expect(server?.source).toBe("project");
+		expect(server?.initialization).toEqual({
+			tsserver: { useSyntaxServer: "auto" },
+			disableAutomaticTypingAcquisition: true,
+			hostInfo: "x",
+		});
+	});
+
+	it("#given a user entry with only a custom command #then no builtin defaults are injected", () => {
+		const server = mergedTypescript({ user: { lsp: { typescript: { command: ["vtsls", "--stdio"] } } } });
+		expect(server?.command).toEqual(["vtsls", "--stdio"]);
+		expect(server?.initialization).toBeUndefined();
+	});
+
+	it("#given a user entry with a custom command #then no builtin defaults are injected", () => {
+		const server = mergedTypescript({
+			user: { lsp: { typescript: { command: ["custom-ts-ls", "--stdio"], extensions: [".ts"] } } },
+		});
+		expect(server?.command).toEqual(["custom-ts-ls", "--stdio"]);
+		expect(server?.initialization).toBeUndefined();
+	});
+});

package/packages/lsp-daemon/dist/cli.js

@@ -445,7 +445,7 @@ function parseEndpoint(value) {
 }
 
 // src/proxy.ts
-import { existsSync as existsSync15, realpathSync as realpathSync6 } from "node:fs";
+import { existsSync as existsSync15, realpathSync as realpathSync7 } from "node:fs";
 import { basename as basename4, delimiter as delimiter4, dirname as dirname14, isAbsolute as isAbsolute6 } from "node:path";
 // ../mcp-stdio-core/src/responses.ts
 function successResponse(id, result) {
@@ -756,7 +756,7 @@ function createIdleTimer(idleTimeoutMs, log, onTimeout) {
   };
 }
 // ../lsp-core/src/lsp/client-wrapper.ts
-import { existsSync as existsSync11, realpathSync as realpathSync5, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync11, realpathSync as realpathSync6, statSync as statSync4 } from "node:fs";
 import { basename as basename3, dirname as dirname11, join as join5, resolve as resolve8 } from "node:path";
 
 // ../lsp-core/src/request-context.ts
@@ -4197,10 +4197,15 @@ var LSP_LOCAL_INSTALL_HINTS = {
   ty: "uv add --dev ty",
   "ruby-lsp": "bundle add ruby-lsp --group development"
 };
+var TYPESCRIPT_SERVER_INITIALIZATION = {
+  tsserver: { useSyntaxServer: "never" },
+  disableAutomaticTypingAcquisition: true
+};
 var BUILTIN_SERVERS = {
   typescript: {
     command: ["typescript-language-server", "--stdio"],
-    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"]
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+    initialization: TYPESCRIPT_SERVER_INITIALIZATION
   },
   deno: { command: ["deno", "lsp"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs"] },
   vue: { command: ["vue-language-server", "--stdio"], extensions: [".vue"] },
@@ -4418,7 +4423,8 @@ function getMergedServers() {
       command: config.command,
       extensions: config.extensions,
       priority: -100,
-      source: "builtin"
+      source: "builtin",
+      ...config.initialization === undefined ? {} : { initialization: config.initialization }
     });
   }
   return servers.sort((a, b) => {
@@ -4445,8 +4451,9 @@ function createServerFromEntry(id, entry, source) {
       priority: entry.priority ?? 0,
       source
     });
-    if (entry.initialization !== undefined) {
-      server.initialization = entry.initialization;
+    const initialization = mergeInitialization(builtin.initialization, entry.initialization);
+    if (initialization !== undefined) {
+      server.initialization = initialization;
     }
     return server;
   }
@@ -4471,8 +4478,20 @@ function createServerFromEntry(id, entry, source) {
     source
   });
   applyOptionalServerFields(server, entry);
+  const builtinInitialization = entry.command === undefined ? builtin.initialization : undefined;
+  const initialization = mergeInitialization(builtinInitialization, entry.initialization);
+  if (initialization !== undefined) {
+    server.initialization = initialization;
+  }
   return server;
 }
+function mergeInitialization(builtin, entry) {
+  if (builtin === undefined)
+    return entry;
+  if (entry === undefined)
+    return builtin;
+  return { ...builtin, ...entry };
+}
 function createServer(input) {
   const server = {
     id: input.id,
@@ -4543,6 +4562,49 @@ function getDisabledServerIds() {
   return disabled;
 }
 
+// ../lsp-core/src/lsp/host-js-runtime.ts
+import { closeSync as closeSync3, openSync as openSync3, readSync, realpathSync as realpathSync5 } from "node:fs";
+var HOST_RUNTIME_SERVER_IDS = new Set(["typescript"]);
+var JS_ENTRY = /\.[cm]?js$/;
+var NODE_SHEBANG = /^#![^\n]*\bnode\b/;
+function currentHostJsRuntime() {
+  return { bunExecPath: process.versions["bun"] === undefined ? undefined : process.execPath };
+}
+function withHostJsRuntime(serverId, command, host = currentHostJsRuntime()) {
+  if (host.bunExecPath === undefined || !HOST_RUNTIME_SERVER_IDS.has(serverId))
+    return command;
+  const [binary, ...args] = command;
+  if (binary === undefined)
+    return command;
+  const script = nodeScriptPath(binary);
+  return script === undefined ? command : [host.bunExecPath, script, ...args];
+}
+function nodeScriptPath(binary) {
+  let real;
+  try {
+    real = realpathSync5(binary);
+  } catch {
+    return;
+  }
+  if (JS_ENTRY.test(real))
+    return real;
+  try {
+    return NODE_SHEBANG.test(readHead(real)) ? real : undefined;
+  } catch {
+    return;
+  }
+}
+function readHead(path) {
+  const fd = openSync3(path, "r");
+  try {
+    const buffer = Buffer.alloc(128);
+    const bytes = readSync(fd, buffer, 0, buffer.length, 0);
+    return buffer.toString("utf8", 0, bytes);
+  } finally {
+    closeSync3(fd);
+  }
+}
+
 // ../lsp-core/src/lsp/server-installation.ts
 import { existsSync as existsSync10 } from "node:fs";
 import { delimiter as delimiter3, dirname as dirname10, isAbsolute as isAbsolute3, join as join4, resolve as resolve7 } from "node:path";
@@ -4682,6 +4744,10 @@ function isServerInstalled(command, workingDirectory, options = {}) {
 function withResolvedCommand(command, binaryPath) {
   return [binaryPath, ...command.slice(1)];
 }
+function usesBuiltinCommand(id, command) {
+  const builtin = BUILTIN_SERVERS[id]?.command;
+  return builtin !== undefined && builtin.length === command.length && builtin.every((part, index) => part === command[index]);
+}
 function findServerForExtension(ext) {
   const servers = getMergedServers();
   const workingDirectory = contextCwd();
@@ -4692,7 +4758,7 @@ function findServerForExtension(ext) {
     if (binaryPath !== null) {
       const resolvedServer = {
         id: server.id,
-        command: withResolvedCommand(server.command, binaryPath),
+        command: usesBuiltinCommand(server.id, server.command) ? withHostJsRuntime(server.id, withResolvedCommand(server.command, binaryPath)) : withResolvedCommand(server.command, binaryPath),
         extensions: server.extensions,
         priority: server.priority
       };
@@ -4833,7 +4899,7 @@ function rebaseThroughCanonicalAncestor(path, cwd) {
   const suffix = [];
   while (true) {
     if (existsSync11(current)) {
-      const canonical = realpathSync5(current);
+      const canonical = realpathSync6(current);
       if (isPathInside(cwd, canonical))
         return suffix.length === 0 ? canonical : join5(canonical, ...suffix);
     }
@@ -4847,7 +4913,7 @@ function rebaseThroughCanonicalAncestor(path, cwd) {
 function existingDirectoryInsideContext(directory, cwd) {
   if (!existsSync11(directory))
     return;
-  const canonical = realpathSync5(directory);
+  const canonical = realpathSync6(directory);
   if (!statSync4(canonical).isDirectory())
     return;
   return isPathInside(cwd, canonical) ? canonical : undefined;
@@ -6441,7 +6507,7 @@ function errorText(error) {
 
 // src/ensure-daemon.ts
 import { spawn as spawn3 } from "node:child_process";
-import { closeSync as closeSync3, existsSync as existsSync14, mkdirSync as mkdirSync4, openSync as openSync3, writeSync as writeSync3 } from "node:fs";
+import { closeSync as closeSync4, existsSync as existsSync14, mkdirSync as mkdirSync4, openSync as openSync4, writeSync as writeSync3 } from "node:fs";
 import { Socket } from "node:net";
 import { dirname as dirname13, isAbsolute as isAbsolute5 } from "node:path";
 import { argv0, execPath } from "node:process";
@@ -6725,7 +6791,7 @@ function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS2, signal) {
 }
 function spawnDaemonProcess(paths, deps = {}) {
   mkdirSync4(dirname13(paths.log), { recursive: true });
-  const logFd = openSync3(paths.log, "a");
+  const logFd = openSync4(paths.log, "a");
   try {
     const spawnDaemonChild = deps.spawn ?? spawn3;
     const executable = deps.resolveExecutable?.() ?? resolveDaemonNodeExecutable();
@@ -6735,15 +6801,15 @@ function spawnDaemonProcess(paths, deps = {}) {
       windowsHide: true,
       env: { ...process.env, BUN_BE_BUN: "1" }
     });
-    child.once("spawn", () => closeSync3(logFd));
+    child.once("spawn", () => closeSync4(logFd));
     child.once("error", (error) => {
       writeSync3(logFd, `[lsp-daemon] failed to spawn daemon: ${error.message}
 `);
-      closeSync3(logFd);
+      closeSync4(logFd);
     });
     child.unref();
   } catch (error) {
-    closeSync3(logFd);
+    closeSync4(logFd);
     throw error;
   }
 }
@@ -7247,7 +7313,7 @@ function canonicalizePathList(value) {
 function canonicalizePath(value) {
   if (value === undefined || !isAbsolute6(value) || !existsSync15(value))
     return value;
-  return realpathSync6(value);
+  return realpathSync7(value);
 }
 function projectRootFromOpenCodeConfigPath(path) {
   if (basename4(path) !== "lsp.json" && basename4(path) !== "lsp-client.json")