lazycodex-ai 5.1.48 → 5.1.54

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);
+	});
+});

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

@@ -0,0 +1,218 @@
+import { existsSync } from "node:fs";
+import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
+
+/**
+ * Project markers that authorize probing a set of repo-local binary directories.
+ *
+ * A local bin directory is only trusted when the sibling marker proves the directory
+ * belongs to a project of that ecosystem. An unmarked `node_modules/.bin` is ignored so
+ * that a stray directory cannot inject an executable into the resolution order.
+ */
+interface LocalBinRule {
+	readonly markers: readonly string[];
+	readonly binDirs: readonly string[];
+}
+
+const LOCAL_BIN_RULES: readonly LocalBinRule[] = [
+	{
+		markers: ["package.json", "bun.lock", "bun.lockb", "package-lock.json", "yarn.lock", "pnpm-lock.yaml"],
+		binDirs: [join("node_modules", ".bin")],
+	},
+	{
+		markers: [
+			"pyproject.toml",
+			"ty.toml",
+			"requirements.txt",
+			"setup.py",
+			"setup.cfg",
+			"Pipfile",
+			"pyrightconfig.json",
+			"ruff.toml",
+			".ruff.toml",
+		],
+		binDirs: [
+			join(".venv", "bin"),
+			join(".venv", "Scripts"),
+			join("venv", "bin"),
+			join("venv", "Scripts"),
+			join(".env", "bin"),
+			join(".env", "Scripts"),
+		],
+	},
+	{
+		markers: ["Gemfile", "Gemfile.lock"],
+		binDirs: [join("vendor", "bundle", "bin"), "bin"],
+	},
+	{
+		markers: ["go.mod", "go.sum", "go.work"],
+		binDirs: ["bin"],
+	},
+];
+
+export interface ResolveServerBinaryOptions {
+	/**
+	 * Upward walk boundary. The walk never ascends above this directory, which lets callers
+	 * confine resolution to a trusted request cwd.
+	 */
+	readonly stopAt?: string;
+	readonly platform?: NodeJS.Platform;
+	readonly pathExt?: string;
+	readonly pathEnv?: string;
+}
+
+const resolutionCache = new Map<string, string | null>();
+let probeCount = 0;
+
+/** Test seam: clears the per-process resolution cache. */
+export function __resetServerBinaryResolutionCacheForTests(): void {
+	resolutionCache.clear();
+	probeCount = 0;
+}
+
+/** Test seam: counts filesystem probes so cache hits are observable. */
+export function __serverBinaryProbeCountForTests(): number {
+	return probeCount;
+}
+
+function probe(path: string): boolean {
+	probeCount += 1;
+	return existsSync(path);
+}
+
+function executableSuffixes(platform: NodeJS.Platform, pathExt: string | undefined): readonly string[] {
+	if (platform !== "win32") return [""];
+	const configured = pathExt ?? process.env["PATHEXT"] ?? "";
+	// PATHEXT is conventionally uppercase, but the on-disk shims npm/bun write are lowercase.
+	// Probe lowercase first so the returned path matches the real filename on case-sensitive
+	// filesystems; the resolved path is spawned, so its casing has to be exact.
+	const systemExts = configured
+		.split(";")
+		.filter((entry) => entry.length > 0)
+		.map((entry) => entry.toLowerCase());
+	return [...new Set(["", ...systemExts, ".exe", ".cmd", ".bat", ".ps1"])];
+}
+
+function probeWithSuffixes(directory: string, command: string, suffixes: readonly string[]): string | null {
+	for (const suffix of suffixes) {
+		const candidate = join(directory, command + suffix);
+		if (probe(candidate)) return candidate;
+	}
+	return null;
+}
+
+function resolveLocal(
+	command: string,
+	workingDirectory: string,
+	suffixes: readonly string[],
+	stopAt: string | undefined,
+): string | null {
+	const boundary = stopAt === undefined ? undefined : resolve(stopAt);
+	let current = resolve(workingDirectory);
+
+	while (true) {
+		for (const rule of LOCAL_BIN_RULES) {
+			if (!rule.markers.some((marker) => probe(join(current, marker)))) continue;
+			for (const binDir of rule.binDirs) {
+				const found = probeWithSuffixes(join(current, binDir), command, suffixes);
+				if (found !== null) return found;
+			}
+		}
+
+		// A repository root ends the walk: tooling above it belongs to a different project.
+		if (probe(join(current, ".git"))) return null;
+		if (boundary !== undefined && current === boundary) return null;
+
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+
+function resolveFromPath(
+	command: string,
+	suffixes: readonly string[],
+	platform: NodeJS.Platform,
+	pathEnvOverride: string | undefined,
+): string | null {
+	let pathEnv = pathEnvOverride ?? process.env["PATH"] ?? "";
+	if (platform === "win32" && !pathEnv) {
+		pathEnv = process.env["Path"] ?? "";
+	}
+
+	for (const entry of pathEnv.split(delimiter)) {
+		if (entry.length === 0) continue;
+		const found = probeWithSuffixes(entry, command, suffixes);
+		if (found !== null) return found;
+	}
+	return null;
+}
+
+/**
+ * Resolves the absolute path of an LSP server binary.
+ *
+ * Probing order:
+ * 1. a path-shaped command is validated as-is,
+ * 2. marker-gated repo-local bin directories, walking up from `workingDirectory`,
+ * 3. `PATH` (including Windows executable suffixes),
+ * 4. `null` when nothing matches.
+ *
+ * Results are cached per process, keyed by working directory and command.
+ */
+export function resolveServerBinary(
+	command: string[],
+	workingDirectory?: string,
+	options: ResolveServerBinaryOptions = {},
+): string | null {
+	if (command.length === 0) return null;
+	const [cmd] = command;
+	if (cmd === undefined || cmd.length === 0) return null;
+
+	const platform = options.platform ?? process.platform;
+	const suffixes = executableSuffixes(platform, options.pathExt);
+
+	if (cmd.includes("/") || cmd.includes("\\")) {
+		const explicit = isAbsolute(cmd) ? cmd : resolve(workingDirectory ?? process.cwd(), cmd);
+		return probe(explicit) ? explicit : null;
+	}
+
+	const cacheKey = JSON.stringify([
+		workingDirectory ?? "",
+		cmd,
+		platform,
+		options.stopAt ?? "",
+		options.pathExt ?? "",
+		options.pathEnv ?? process.env["PATH"] ?? "",
+	]);
+	const cached = resolutionCache.get(cacheKey);
+	if (cached !== undefined) return cached;
+
+	let resolved: string | null = null;
+	if (workingDirectory !== undefined && workingDirectory.length > 0) {
+		resolved = resolveLocal(cmd, workingDirectory, suffixes, options.stopAt);
+	}
+	resolved ??= resolveFromPath(cmd, suffixes, platform, options.pathEnv);
+	// A configured server may be launched through the interpreter itself, e.g.
+	// { command: ["node", "my-ls.js"] }. isServerInstalled() has always treated bare `node`
+	// as available regardless of PATH, so keep those servers selectable instead of
+	// regressing them into a not_installed result. The name is returned unresolved so the
+	// spawn still goes through `node`; rewriting it to process.execPath would silently
+	// substitute a different interpreter (bun) for the one the config asked for.
+	if (resolved === null && cmd === "node") resolved = cmd;
+
+	resolutionCache.set(cacheKey, resolved);
+	return resolved;
+}
+
+/**
+ * Reports whether an LSP server binary is available.
+ *
+ * Retained for existing consumers; `resolveServerBinary` is the richer entry point.
+ */
+export function isServerInstalled(
+	command: string[],
+	workingDirectory?: string,
+	options: ResolveServerBinaryOptions = {},
+): boolean {
+	if (command.length === 0) return false;
+	return resolveServerBinary(command, workingDirectory, options) !== null;
+}