oh-my-opencode 5.0.0-beta.3 → 5.0.0-beta.31

package/packages/lsp-core/src/lsp/outside-context-workspace.ts

@@ -0,0 +1,33 @@
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { WORKSPACE_MARKERS } from "./workspace-markers.js";
+
+/** Read-only tools accept out-of-cwd files, so cwd cannot bound this search; the fallback keeps the server scoped to the file's own directory. */
+export function findWorkspaceRootOutsideContext(directory: string): string {
+	const marked = nearestMarkedAncestor(directory);
+	if (marked !== undefined) return marked;
+	return realpathSync(nearestExistingAncestor(directory));
+}
+
+function nearestMarkedAncestor(directory: string): string | undefined {
+	let current = directory;
+	for (;;) {
+		if (existsSync(current) && WORKSPACE_MARKERS.some((marker) => existsSync(join(current, marker)))) {
+			return realpathSync(current);
+		}
+		const parent = dirname(current);
+		if (parent === current) return undefined;
+		current = parent;
+	}
+}
+
+function nearestExistingAncestor(directory: string): string {
+	let current = directory;
+	while (!existsSync(current)) {
+		const parent = dirname(current);
+		if (parent === current) return current;
+		current = parent;
+	}
+	return current;
+}

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

@@ -49,6 +49,35 @@ export const LSP_INSTALL_HINTS: Record<string, string> = {
 		"Install: dotnet tool install -g roslyn-language-server --prerelease (requires v5.8.0+). See https://github.com/dotnet/razor",
 };
 
+/**
+ * Repo-local install commands, offered ahead of the global hints in `LSP_INSTALL_HINTS`.
+ *
+ * A devDependency (or project venv) is resolvable by `resolveServerBinary()` without any
+ * global install, and it pins the version the project actually expects. Only servers that
+ * are genuinely distributed per-project belong here; toolchain-wide servers (rust-analyzer,
+ * gopls, clangd, ...) keep their global hint alone.
+ */
+export const LSP_LOCAL_INSTALL_HINTS: Record<string, string> = {
+	typescript: "bun add -d typescript-language-server typescript",
+	vue: "bun add -d @vue/language-server",
+	eslint: "bun add -d vscode-langservers-extracted",
+	oxlint: "bun add -d oxlint",
+	biome: "bun add -d @biomejs/biome",
+	svelte: "bun add -d svelte-language-server",
+	astro: "bun add -d @astrojs/language-server",
+	bash: "bun add -d bash-language-server",
+	"bash-ls": "bun add -d bash-language-server",
+	"yaml-ls": "bun add -d yaml-language-server",
+	php: "bun add -d intelephense",
+	prisma: "bun add -d prisma",
+	dockerfile: "bun add -d dockerfile-language-server-nodejs",
+	pyright: "uv add --dev pyright",
+	basedpyright: "uv add --dev basedpyright",
+	ruff: "uv add --dev ruff",
+	ty: "uv add --dev ty",
+	"ruby-lsp": "bundle add ruby-lsp --group development",
+};
+
 export const BUILTIN_SERVERS: Record<string, Omit<LspServerConfig, "id">> = {
 	typescript: {
 		command: ["typescript-language-server", "--stdio"],

package/packages/lsp-core/src/lsp/server-installation.test.ts

@@ -0,0 +1,376 @@
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+	__resetServerBinaryResolutionCacheForTests,
+	__serverBinaryProbeCountForTests,
+	isServerInstalled,
+	resolveServerBinary,
+} from "./server-installation.js";
+
+const tempDirectories: string[] = [];
+let previousPath: string | undefined;
+
+function makeTempRoot(prefix: string): string {
+	const root = mkdtempSync(join(tmpdir(), prefix));
+	tempDirectories.push(root);
+	return root;
+}
+
+function writeExecutable(path: string, body = "#!/bin/sh\nexit 0\n"): string {
+	mkdirSync(join(path, ".."), { recursive: true });
+	writeFileSync(path, body);
+	chmodSync(path, 0o755);
+	return path;
+}
+
+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("resolveServerBinary node marker resolution", () => {
+	test("#given a package.json marker and a local node bin #when resolving with an empty PATH #then it returns the local absolute path", () => {
+		// given
+		const root = makeTempRoot("lsp-local-node-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		const binaryPath = writeExecutable(join(root, "node_modules", ".bin", "biome"));
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const resolved = resolveServerBinary(["biome", "lsp-proxy", "--stdio"], root);
+
+		// then
+		expect(resolved).toBe(binaryPath);
+	});
+
+	test("#given a nested working directory #when resolving #then it walks up to the marker root", () => {
+		// given
+		const root = makeTempRoot("lsp-local-nested-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		const binaryPath = writeExecutable(join(root, "node_modules", ".bin", "biome"));
+		const nested = join(root, "packages", "deep", "src");
+		mkdirSync(nested, { recursive: true });
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const resolved = resolveServerBinary(["biome", "lsp-proxy", "--stdio"], nested);
+
+		// then
+		expect(resolved).toBe(binaryPath);
+	});
+
+	test("#given a local bin without any project marker #when resolving #then the unmarked directory is not trusted", () => {
+		// given
+		const root = makeTempRoot("lsp-local-unmarked-");
+		writeExecutable(join(root, "node_modules", ".bin", "biome"));
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const resolved = resolveServerBinary(["biome", "lsp-proxy", "--stdio"], root);
+
+		// then
+		expect(resolved).toBeNull();
+	});
+
+	test("#given a bun.lock marker #when resolving #then the node bin directory is probed", () => {
+		// given
+		const root = makeTempRoot("lsp-local-bunlock-");
+		writeFileSync(join(root, "bun.lock"), "");
+		const binaryPath = writeExecutable(join(root, "node_modules", ".bin", "biome"));
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when / then
+		expect(resolveServerBinary(["biome"], root)).toBe(binaryPath);
+	});
+});
+
+describe("resolveServerBinary non-node ecosystems", () => {
+	test("#given a pyproject marker and a venv binary #when resolving #then it returns the venv path", () => {
+		// given
+		const root = makeTempRoot("lsp-local-python-");
+		writeFileSync(join(root, "pyproject.toml"), "[project]\n");
+		const binaryPath = writeExecutable(join(root, ".venv", "bin", "ruff"));
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when / then
+		expect(resolveServerBinary(["ruff", "server"], root)).toBe(binaryPath);
+	});
+
+	test("#given a Gemfile marker and a bundled binary #when resolving #then it returns the vendored bundle path", () => {
+		// given
+		const root = makeTempRoot("lsp-local-ruby-");
+		writeFileSync(join(root, "Gemfile"), "source 'https://rubygems.org'\n");
+		const binaryPath = writeExecutable(join(root, "vendor", "bundle", "bin", "rubocop"));
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when / then
+		expect(resolveServerBinary(["rubocop", "--lsp"], root)).toBe(binaryPath);
+	});
+
+	test("#given a go.mod marker and a project bin #when resolving #then it returns the project bin path", () => {
+		// given
+		const root = makeTempRoot("lsp-local-go-");
+		writeFileSync(join(root, "go.mod"), "module example.com/demo\n");
+		const binaryPath = writeExecutable(join(root, "bin", "gopls"));
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when / then
+		expect(resolveServerBinary(["gopls"], root)).toBe(binaryPath);
+	});
+
+	test("#given a python marker without a matching venv binary #when resolving #then node bin dirs are not borrowed", () => {
+		// given
+		const root = makeTempRoot("lsp-local-python-miss-");
+		writeFileSync(join(root, "requirements.txt"), "ruff\n");
+		writeExecutable(join(root, "node_modules", ".bin", "ruff"));
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when / then
+		expect(resolveServerBinary(["ruff", "server"], root)).toBeNull();
+	});
+});
+
+describe("resolveServerBinary probe ordering", () => {
+	test("#given a local binary and a PATH binary #when resolving #then the local binary wins", () => {
+		// given
+		const root = makeTempRoot("lsp-local-priority-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		const localBinary = writeExecutable(join(root, "node_modules", ".bin", "biome"));
+		const pathDir = makeTempRoot("lsp-path-priority-");
+		writeExecutable(join(pathDir, "biome"));
+		process.env["PATH"] = pathDir;
+
+		// when / then
+		expect(resolveServerBinary(["biome"], root)).toBe(localBinary);
+	});
+
+	test("#given only a PATH binary #when resolving #then the PATH entry is returned", () => {
+		// given
+		const root = makeTempRoot("lsp-path-fallback-root-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		const pathDir = makeTempRoot("lsp-path-fallback-");
+		const pathBinary = writeExecutable(join(pathDir, "biome"));
+		process.env["PATH"] = pathDir;
+
+		// when / then
+		expect(resolveServerBinary(["biome"], root)).toBe(pathBinary);
+	});
+
+	test("#given a path-shaped command #when resolving #then the command path itself is validated", () => {
+		// given
+		const root = makeTempRoot("lsp-explicit-path-");
+		const binaryPath = writeExecutable(join(root, "tools", "custom-ls"));
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when / then
+		expect(resolveServerBinary([binaryPath, "--stdio"], root)).toBe(binaryPath);
+		expect(resolveServerBinary([join(root, "tools", "absent-ls")], root)).toBeNull();
+	});
+
+	test("#given no working directory #when resolving #then it falls back to PATH only", () => {
+		// given
+		const pathDir = makeTempRoot("lsp-no-cwd-");
+		const pathBinary = writeExecutable(join(pathDir, "biome"));
+		process.env["PATH"] = pathDir;
+
+		// when / then
+		expect(resolveServerBinary(["biome"])).toBe(pathBinary);
+	});
+
+	test("#given nothing anywhere #when resolving #then it returns null", () => {
+		// given
+		const root = makeTempRoot("lsp-unresolved-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when / then
+		expect(resolveServerBinary(["biome"], root)).toBeNull();
+		expect(resolveServerBinary([], root)).toBeNull();
+	});
+});
+
+describe("resolveServerBinary containment", () => {
+	test("#given a marker only above the working directory root #when resolving with a stop boundary #then it does not escape the boundary", () => {
+		// given
+		const outer = makeTempRoot("lsp-boundary-outer-");
+		writeFileSync(join(outer, "package.json"), "{}\n");
+		writeExecutable(join(outer, "node_modules", ".bin", "biome"));
+		const inner = join(outer, "inner");
+		mkdirSync(inner, { recursive: true });
+		process.env["PATH"] = join(outer, "definitely-empty");
+
+		// when / then
+		expect(resolveServerBinary(["biome"], inner, { stopAt: inner })).toBeNull();
+		expect(resolveServerBinary(["biome"], inner)).toBe(join(outer, "node_modules", ".bin", "biome"));
+	});
+
+	test("#given a git repository boundary #when resolving #then the walk stops at the repository root", () => {
+		// given
+		const outer = makeTempRoot("lsp-git-boundary-");
+		writeFileSync(join(outer, "package.json"), "{}\n");
+		writeExecutable(join(outer, "node_modules", ".bin", "biome"));
+		const repo = join(outer, "repo");
+		mkdirSync(join(repo, ".git"), { recursive: true });
+		process.env["PATH"] = join(outer, "definitely-empty");
+
+		// when / then
+		expect(resolveServerBinary(["biome"], repo)).toBeNull();
+	});
+});
+
+describe("resolveServerBinary windows suffix probing", () => {
+	test("#given a windows platform and a .cmd shim #when resolving locally #then the suffixed binary is found", () => {
+		// given
+		const root = makeTempRoot("lsp-win-local-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		const binaryPath = writeExecutable(join(root, "node_modules", ".bin", "biome.cmd"));
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const resolved = resolveServerBinary(["biome"], root, { platform: "win32", pathExt: ".COM;.EXE;.CMD" });
+
+		// then
+		expect(resolved).toBe(binaryPath);
+	});
+
+	test("#given a windows platform and a PATH .exe #when resolving #then the suffixed PATH entry is found", () => {
+		// given
+		const pathDir = makeTempRoot("lsp-win-path-");
+		const binaryPath = writeExecutable(join(pathDir, "biome.exe"));
+		process.env["PATH"] = pathDir;
+
+		// when / then
+		expect(resolveServerBinary(["biome"], undefined, { platform: "win32", pathExt: ".COM;.EXE" })).toBe(binaryPath);
+	});
+});
+
+describe("resolveServerBinary caching", () => {
+	test("#given a repeated lookup #when resolving twice #then the filesystem is probed only once", () => {
+		// given
+		const root = makeTempRoot("lsp-cache-hit-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		const binaryPath = writeExecutable(join(root, "node_modules", ".bin", "biome"));
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const first = resolveServerBinary(["biome"], root);
+		const probesAfterFirst = __serverBinaryProbeCountForTests();
+		const second = resolveServerBinary(["biome"], root);
+		const probesAfterSecond = __serverBinaryProbeCountForTests();
+
+		// then
+		expect(first).toBe(binaryPath);
+		expect(second).toBe(binaryPath);
+		expect(probesAfterFirst).toBeGreaterThan(0);
+		expect(probesAfterSecond).toBe(probesAfterFirst);
+	});
+
+	test("#given a cached negative lookup #when resolving twice #then the miss is also cached", () => {
+		// given
+		const root = makeTempRoot("lsp-cache-miss-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		expect(resolveServerBinary(["biome"], root)).toBeNull();
+		const probesAfterFirst = __serverBinaryProbeCountForTests();
+		expect(resolveServerBinary(["biome"], root)).toBeNull();
+
+		// then
+		expect(__serverBinaryProbeCountForTests()).toBe(probesAfterFirst);
+	});
+
+	test("#given distinct working directories #when resolving the same command #then the cache keys stay separate", () => {
+		// given
+		const first = makeTempRoot("lsp-cache-key-a-");
+		writeFileSync(join(first, "package.json"), "{}\n");
+		const firstBinary = writeExecutable(join(first, "node_modules", ".bin", "biome"));
+		const second = makeTempRoot("lsp-cache-key-b-");
+		writeFileSync(join(second, "package.json"), "{}\n");
+		process.env["PATH"] = join(first, "definitely-empty");
+
+		// when / then
+		expect(resolveServerBinary(["biome"], first)).toBe(firstBinary);
+		expect(resolveServerBinary(["biome"], second)).toBeNull();
+	});
+});
+
+describe("isServerInstalled compatibility", () => {
+	test("#given a repo-local binary #when checking installation #then it reports installed", () => {
+		// given
+		const root = makeTempRoot("lsp-compat-local-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		writeExecutable(join(root, "node_modules", ".bin", "biome"));
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when / then
+		expect(isServerInstalled(["biome", "lsp-proxy"], root)).toBe(true);
+	});
+
+	test("#given a PATH binary and no working directory #when checking installation #then it reports installed", () => {
+		// given
+		const pathDir = makeTempRoot("lsp-compat-path-");
+		writeExecutable(join(pathDir, "typescript-language-server"));
+		process.env["PATH"] = pathDir;
+
+		// when / then
+		expect(isServerInstalled(["typescript-language-server", "--stdio"])).toBe(true);
+	});
+
+	test("#given no binary at all #when checking installation #then it reports not installed", () => {
+		// given
+		const root = makeTempRoot("lsp-compat-missing-");
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when / then
+		expect(isServerInstalled(["totally-absent-language-server"], root)).toBe(false);
+		expect(isServerInstalled([])).toBe(false);
+	});
+
+	test("#given the node command #when checking installation #then the existing node allowance is preserved", () => {
+		// given
+		const root = makeTempRoot("lsp-compat-node-");
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when / then
+		expect(isServerInstalled(["node", "server.js"], root)).toBe(true);
+	});
+});
+
+describe("resolveServerBinary node fallback", () => {
+	test("#given a node command missing from PATH #when resolving #then the name is kept so the server stays selectable", () => {
+		// given: a user-configured server such as { command: ["node", "my-ls.js"] } must keep
+		// working, matching the node allowance isServerInstalled() has always had.
+		const root = makeTempRoot("lsp-node-fallback-");
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const resolved = resolveServerBinary(["node", "server.js"], root);
+
+		// then: unresolved rather than rewritten, so the spawn still goes through node
+		expect(resolved).toBe("node");
+		expect(isServerInstalled(["node", "server.js"], root)).toBe(true);
+	});
+
+	test("#given a node command present on PATH #when resolving #then the PATH entry still wins", () => {
+		// given
+		const pathDir = makeTempRoot("lsp-node-on-path-");
+		const pathBinary = writeExecutable(join(pathDir, "node"));
+		process.env["PATH"] = pathDir;
+
+		// when / then
+		expect(resolveServerBinary(["node", "server.js"])).toBe(pathBinary);
+	});
+});