pi-lens 3.8.18 → 3.8.21

package/clients/lsp/server.ts

@@ -24,20 +24,154 @@ import {
 
 export type RootFunction = (file: string) => Promise<string | undefined>;
 
+export interface LSPSpawnOptions {
+	allowInstall?: boolean;
+}
+
 export interface LSPServerInfo {
 	id: string;
 	name: string;
 	extensions: string[];
 	root: RootFunction;
+	installPolicy?: "none" | "interactive" | "managed" | "package-manager";
 	spawn(
 		root: string,
+		options?: LSPSpawnOptions,
 	): Promise<
-		| { process: LSPProcess; initialization?: Record<string, unknown> }
+		| {
+				process: LSPProcess;
+				initialization?: Record<string, unknown>;
+				source?: "direct" | "managed" | "package-manager" | "interactive";
+		  }
 		| undefined
 	>;
 	autoInstall?: () => Promise<boolean>;
 }
 
+function isLspInstallDisabled(): boolean {
+	return process.env.PI_LENS_DISABLE_LSP_INSTALL === "1";
+}
+
+function canInstall(allowInstall?: boolean): boolean {
+	return allowInstall !== false && !isLspInstallDisabled();
+}
+
+function isCommandNotFoundError(error: unknown): boolean {
+	const msg = String(error);
+	return msg.includes("not found") || msg.includes("ENOENT");
+}
+
+async function launchViaPackageManagerWithPolicy(
+	packageName: string,
+	args: string[],
+	options: { cwd: string; allowInstall?: boolean },
+): Promise<LSPProcess | undefined> {
+	if (!canInstall(options.allowInstall)) {
+		return undefined;
+	}
+	return launchViaPackageManager(packageName, args, options);
+}
+
+function nodeBinCandidates(root: string, baseName: string): string[] {
+	const localBase = path.join(root, "node_modules", ".bin", baseName);
+	if (process.platform === "win32") {
+		return [
+			`${localBase}.cmd`,
+			`${localBase}.ps1`,
+			`${localBase}.exe`,
+			localBase,
+			baseName,
+		];
+	}
+	return [localBase, baseName];
+}
+
+async function launchWithDirectOrPackageManager(
+	directCommands: string[],
+	packageName: string,
+	args: string[],
+	options: { cwd: string; env?: NodeJS.ProcessEnv; allowInstall?: boolean },
+): Promise<{ process: LSPProcess; source: "direct" | "package-manager" } | undefined> {
+	for (const command of directCommands) {
+		try {
+			const process = await launchLSP(command, args, options);
+			return { process, source: "direct" };
+		} catch (error) {
+			if (!isCommandNotFoundError(error)) {
+				throw error;
+			}
+		}
+	}
+
+	const process = await launchViaPackageManagerWithPolicy(packageName, args, {
+		cwd: options.cwd,
+		allowInstall: options.allowInstall,
+	});
+	if (!process) return undefined;
+	return { process, source: "package-manager" };
+}
+
+type InitializationConfig = Record<string, unknown>;
+
+interface InteractiveServerSpec {
+	id: string;
+	name: string;
+	extensions: string[];
+	root: RootFunction;
+	language: string;
+	command: string | ((root: string) => string);
+	args?: string[] | ((root: string) => string[]);
+	initialization?: InitializationConfig | ((root: string) => InitializationConfig);
+}
+
+function createInteractiveServer(spec: InteractiveServerSpec): LSPServerInfo {
+	return {
+		id: spec.id,
+		name: spec.name,
+		installPolicy: "interactive",
+		extensions: spec.extensions,
+		root: spec.root,
+		async spawn(root, options) {
+			const command =
+				typeof spec.command === "function" ? spec.command(root) : spec.command;
+			const args =
+				typeof spec.args === "function"
+					? spec.args(root)
+					: spec.args || [];
+			const proc = await spawnWithInteractiveInstall(
+				spec.language,
+				command,
+				args,
+				{ cwd: root, allowInstall: options?.allowInstall },
+				async () => await launchLSP(command, args, { cwd: root }),
+			);
+			if (!proc) return undefined;
+			const initialization =
+				typeof spec.initialization === "function"
+					? spec.initialization(root)
+					: spec.initialization;
+			return { process: proc, source: "interactive", initialization };
+		},
+	};
+}
+
+export function PriorityRoot(
+	markerGroups: string[][],
+	excludePatterns?: string[],
+	stopDir?: string,
+): RootFunction {
+	const resolvers = markerGroups.map((markers) =>
+		NearestRoot(markers, excludePatterns, stopDir),
+	);
+	return async (file: string) => {
+		for (const resolve of resolvers) {
+			const root = await resolve(file);
+			if (root) return root;
+		}
+		return undefined;
+	};
+}
+
 // --- Root Detection Helpers ---
 
 import { dirname } from "node:path";
@@ -58,12 +192,15 @@ async function spawnWithInteractiveInstall(
 	language: string,
 	_command: string,
 	_args: string[],
-	options: { cwd: string },
+	options: { cwd: string; allowInstall?: boolean },
 	spawnFn: () => LSPProcess | Promise<LSPProcess>,
 ): Promise<LSPProcess | undefined> {
 	try {
 		return await spawnFn();
 	} catch (error) {
+		if (!canInstall(options.allowInstall)) {
+			return undefined;
+		}
 		// Check if this is a "command not found" error
 		const errorMsg = String(error);
 		if (!errorMsg.includes("not found") && !errorMsg.includes("ENOENT")) {
@@ -103,9 +240,9 @@ export function NearestRoot(
 	stopDir?: string,
 ): RootFunction {
 	return async (file: string): Promise<string | undefined> => {
-		let currentDir = path.dirname(file);
+		let currentDir = path.resolve(path.dirname(file));
 		const fsRoot = path.parse(currentDir).root;
-		const stop = stopDir ?? fsRoot;
+		const stop = stopDir ? path.resolve(stopDir) : fsRoot;
 
 		while (currentDir !== fsRoot) {
 			// Bail out if we've reached the stop boundary
@@ -160,6 +297,7 @@ export const createRootDetector = NearestRoot;
 export const TypeScriptServer: LSPServerInfo = {
 	id: "typescript",
 	name: "TypeScript Language Server",
+	installPolicy: "managed",
 	extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
 	root: createRootDetector([
 		"package-lock.json",
@@ -169,9 +307,10 @@ export const TypeScriptServer: LSPServerInfo = {
 		"yarn.lock",
 		"package.json",
 	]),
-	async spawn(root) {
+	async spawn(root, options) {
 		const path = await import("node:path");
 		const fs = await import("node:fs/promises");
+		let source: "direct" | "managed" = "direct";
 
 		// Find typescript-language-server - prefer local project version
 		let lspPath: string | undefined;
@@ -201,7 +340,10 @@ export const TypeScriptServer: LSPServerInfo = {
 
 		// Fall back to auto-installed version
 		if (!lspPath) {
-			lspPath = await ensureTool("typescript-language-server");
+			if (canInstall(options?.allowInstall)) {
+				lspPath = await ensureTool("typescript-language-server");
+				source = "managed";
+			}
 			if (!lspPath) {
 				console.error("[lsp] typescript-language-server not found");
 				return undefined;
@@ -242,6 +384,26 @@ export const TypeScriptServer: LSPServerInfo = {
 			}
 		}
 
+		if (!tsserverPath && canInstall(options?.allowInstall)) {
+			const tscPath = await ensureTool("typescript");
+			if (tscPath) {
+				const managedTsserverCandidates = [
+					path.join(path.dirname(tscPath), "..", "typescript", "lib", "tsserver.js"),
+					path.join(path.dirname(tscPath), "..", "..", "typescript", "lib", "tsserver.js"),
+				];
+				for (const checkPath of managedTsserverCandidates) {
+					try {
+						await fs.access(checkPath);
+						tsserverPath = checkPath;
+						source = "managed";
+						break;
+					} catch {
+						/* not found */
+					}
+				}
+			}
+		}
+
 		// Use absolute path and proper environment
 		const env = await getToolEnvironment();
 		const proc = await launchLSP(lspPath, ["--stdio"], {
@@ -254,6 +416,7 @@ export const TypeScriptServer: LSPServerInfo = {
 
 		return {
 			process: proc,
+			source,
 			initialization: tsserverPath
 				? { tsserver: { path: tsserverPath } }
 				: undefined,
@@ -264,8 +427,10 @@ export const TypeScriptServer: LSPServerInfo = {
 export const PythonServer: LSPServerInfo = {
 	id: "python",
 	name: "Pyright Language Server",
+	installPolicy: "managed",
 	extensions: [".py", ".pyi"],
 	root: createRootDetector([
+		".git",
 		"pyproject.toml",
 		"setup.py",
 		"setup.cfg",
@@ -273,10 +438,11 @@ export const PythonServer: LSPServerInfo = {
 		"Pipfile",
 		"poetry.lock",
 	]),
-	async spawn(root) {
+	async spawn(root, options) {
 		const path = await import("node:path");
 		const fs = await import("node:fs/promises");
 		const env = await getToolEnvironment();
+		let source: "direct" | "managed" | "package-manager" = "direct";
 
 		// Strategy 1: Find pyright - prefer local project version
 		let pyrightPath: string | undefined;
@@ -301,7 +467,10 @@ export const PythonServer: LSPServerInfo = {
 
 		// Strategy 2: Fall back to auto-installed version
 		if (!pyrightPath) {
-			pyrightPath = await ensureTool("pyright");
+			if (canInstall(options?.allowInstall)) {
+				pyrightPath = await ensureTool("pyright");
+				source = "managed";
+			}
 			if (!pyrightPath) {
 				console.error("[lsp] pyright not found, falling back to npx");
 			}
@@ -327,7 +496,9 @@ export const PythonServer: LSPServerInfo = {
 				try {
 					await fs.access(candidate);
 					langserverPath = candidate;
-					console.error(`[lsp] Found pyright-langserver: ${candidate}`);
+					if (process.env.PI_LENS_DEBUG === "1") {
+						console.error(`[lsp] Found pyright-langserver: ${candidate}`);
+					}
 					break;
 				} catch {
 					/* not found */
@@ -344,12 +515,27 @@ export const PythonServer: LSPServerInfo = {
 				env,
 			});
 		} else {
-			// Fallback to npx for auto-download
-			console.error("[lsp] Falling back to npx for pyright-langserver");
-			proc = await launchViaPackageManager("pyright-langserver", ["--stdio"], {
-				cwd: root,
-				env,
-			});
+			if (!canInstall(options?.allowInstall)) {
+				try {
+					proc = await launchLSP("pyright-langserver", ["--stdio"], {
+						cwd: root,
+						env,
+					});
+				} catch {
+					return undefined;
+				}
+			} else {
+				// Fallback to npx for auto-download
+				console.error("[lsp] Falling back to npx for pyright-langserver");
+				const managed = await launchViaPackageManagerWithPolicy(
+					"pyright-langserver",
+					["--stdio"],
+					{ cwd: root, allowInstall: options?.allowInstall },
+				);
+				if (!managed) return undefined;
+				proc = managed;
+				source = "package-manager";
+			}
 		}
 
 		// Detect virtual environment
@@ -377,7 +563,7 @@ export const PythonServer: LSPServerInfo = {
 			}
 		}
 
-		return { process: proc, initialization };
+		return { process: proc, initialization, source };
 	},
 };
 
@@ -385,13 +571,14 @@ export const GoServer: LSPServerInfo = {
 	id: "go",
 	name: "gopls",
 	extensions: [".go"],
-	root: createRootDetector(["go.mod", "go.sum"]),
-	async spawn(root) {
+	installPolicy: "interactive",
+	root: PriorityRoot([["go.work"], ["go.mod", "go.sum"]]),
+	async spawn(root, options) {
 		const proc = await spawnWithInteractiveInstall(
 			"go",
 			"gopls",
 			[],
-			{ cwd: root },
+			{ cwd: root, allowInstall: options?.allowInstall },
 			async () => await launchLSP("gopls", [], { cwd: root }),
 		);
 		// gopls works best with minimal initialization options
@@ -414,13 +601,14 @@ export const RustServer: LSPServerInfo = {
 	id: "rust",
 	name: "rust-analyzer",
 	extensions: [".rs"],
+	installPolicy: "interactive",
 	root: createRootDetector(["Cargo.toml", "Cargo.lock"]),
-	async spawn(root) {
+	async spawn(root, options) {
 		const proc = await spawnWithInteractiveInstall(
 			"rust",
 			"rust-analyzer",
 			[],
-			{ cwd: root },
+			{ cwd: root, allowInstall: options?.allowInstall },
 			async () => await launchLSP("rust-analyzer", [], { cwd: root }),
 		);
 		// rust-analyzer needs minimal initialization to avoid capability mismatches
@@ -443,165 +631,122 @@ export const RustServer: LSPServerInfo = {
 export const RubyServer: LSPServerInfo = {
 	id: "ruby",
 	name: "Ruby LSP",
+	installPolicy: "interactive",
 	extensions: [".rb", ".rake", ".gemspec", ".ru"],
-	root: createRootDetector(["Gemfile", ".ruby-version"]),
-	async spawn(root) {
+	root: PriorityRoot([["Gemfile", ".ruby-version"], [".git"]]),
+	async spawn(root, options) {
 		// Try ruby-lsp first (prompts to install via gem if missing), fall back to solargraph
 		const proc = await spawnWithInteractiveInstall(
 			"ruby",
 			"ruby-lsp",
 			[],
-			{ cwd: root },
+			{ cwd: root, allowInstall: options?.allowInstall },
 			async () => {
 				try {
 					return await launchLSP("ruby-lsp", [], { cwd: root });
 				} catch {
-					return await launchViaPackageManager("solargraph", ["stdio"], { cwd: root });
+					const fallback = await launchWithDirectOrPackageManager(
+						nodeBinCandidates(root, "solargraph"),
+						"solargraph",
+						["stdio"],
+						{ cwd: root, allowInstall: options?.allowInstall },
+					);
+					if (!fallback) throw new Error("ENOENT: command not found");
+					return fallback.process;
 				}
 			},
 		);
-		return proc ? { process: proc } : undefined;
+		return proc ? { process: proc, source: "interactive" } : undefined;
 	},
 };
 
 export const PHPServer: LSPServerInfo = {
 	id: "php",
 	name: "Intelephense",
+	installPolicy: "package-manager",
 	extensions: [".php"],
 	root: createRootDetector(["composer.json", "composer.lock"]),
-	async spawn(root) {
-		const proc = await launchViaPackageManager("intelephense", ["--stdio"], {
-			cwd: root,
-		});
+	async spawn(root, options) {
+		const launched = await launchWithDirectOrPackageManager(
+			nodeBinCandidates(root, "intelephense"),
+			"intelephense",
+			["--stdio"],
+			{ cwd: root, allowInstall: options?.allowInstall },
+		);
+		if (!launched) return undefined;
 		return {
-			process: proc,
+			process: launched.process,
+			source: launched.source,
 			initialization: { storagePath: path.join(__dirname, ".intelephense") },
 		};
 	},
 };
 
-export const CSharpServer: LSPServerInfo = {
+export const CSharpServer = createInteractiveServer({
 	id: "csharp",
 	name: "csharp-ls",
 	extensions: [".cs"],
 	root: createRootDetector([".sln", ".csproj", ".slnx"]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"csharp",
-			"csharp-ls",
-			[],
-			{ cwd: root },
-			async () => await launchLSP("csharp-ls", [], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "csharp",
+	command: "csharp-ls",
+});
 
-export const FSharpServer: LSPServerInfo = {
+export const FSharpServer = createInteractiveServer({
 	id: "fsharp",
 	name: "FSAutocomplete",
 	extensions: [".fs", ".fsi", ".fsx"],
 	root: createRootDetector([".sln", ".fsproj"]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"fsharp",
-			"fsautocomplete",
-			[],
-			{ cwd: root },
-			async () => await launchLSP("fsautocomplete", [], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "fsharp",
+	command: "fsautocomplete",
+});
 
-export const JavaServer: LSPServerInfo = {
+export const JavaServer = createInteractiveServer({
 	id: "java",
 	name: "JDT Language Server",
 	extensions: [".java"],
 	root: createRootDetector(["pom.xml", "build.gradle", ".classpath"]),
-	async spawn(root) {
-		const jdtlsPath = process.env.JDTLS_PATH || "jdtls";
-		const proc = await spawnWithInteractiveInstall(
-			"java",
-			jdtlsPath,
-			[],
-			{ cwd: root },
-			async () => await launchLSP(jdtlsPath, [], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "java",
+	command: () => process.env.JDTLS_PATH || "jdtls",
+});
 
-export const KotlinServer: LSPServerInfo = {
+export const KotlinServer = createInteractiveServer({
 	id: "kotlin",
 	name: "Kotlin Language Server",
 	extensions: [".kt", ".kts"],
 	root: createRootDetector(["build.gradle.kts", "build.gradle", "pom.xml"]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"kotlin",
-			"kotlin-language-server",
-			[],
-			{ cwd: root },
-			async () => await launchLSP("kotlin-language-server", [], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "kotlin",
+	command: "kotlin-language-server",
+});
 
-export const SwiftServer: LSPServerInfo = {
+export const SwiftServer = createInteractiveServer({
 	id: "swift",
 	name: "SourceKit-LSP",
 	extensions: [".swift"],
 	root: createRootDetector(["Package.swift"]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"swift",
-			"sourcekit-lsp",
-			[],
-			{ cwd: root },
-			async () => await launchLSP("sourcekit-lsp", [], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "swift",
+	command: "sourcekit-lsp",
+});
 
-export const DartServer: LSPServerInfo = {
+export const DartServer = createInteractiveServer({
 	id: "dart",
 	name: "Dart Analysis Server",
 	extensions: [".dart"],
 	root: createRootDetector(["pubspec.yaml"]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"dart",
-			"dart",
-			["language-server", "--protocol=lsp"],
-			{ cwd: root },
-			async () =>
-				await launchLSP("dart", ["language-server", "--protocol=lsp"], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "dart",
+	command: "dart",
+	args: ["language-server", "--protocol=lsp"],
+});
 
-export const LuaServer: LSPServerInfo = {
+export const LuaServer = createInteractiveServer({
 	id: "lua",
 	name: "Lua Language Server",
 	extensions: [".lua"],
 	root: createRootDetector([".luarc.json", ".luacheckrc"]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"lua",
-			"lua-language-server",
-			[],
-			{ cwd: root },
-			async () => await launchLSP("lua-language-server", [], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "lua",
+	command: "lua-language-server",
+});
 
-export const CppServer: LSPServerInfo = {
+export const CppServer = createInteractiveServer({
 	id: "cpp",
 	name: "clangd",
 	extensions: [".c", ".cpp", ".cc", ".cxx", ".h", ".hpp"],
@@ -611,167 +756,99 @@ export const CppServer: LSPServerInfo = {
 		"CMakeLists.txt",
 		"Makefile",
 	]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"cpp",
-			"clangd",
-			["--background-index"],
-			{ cwd: root },
-			async () => await launchLSP("clangd", ["--background-index"], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "cpp",
+	command: "clangd",
+	args: ["--background-index"],
+});
 
-export const ZigServer: LSPServerInfo = {
+export const ZigServer = createInteractiveServer({
 	id: "zig",
 	name: "ZLS",
 	extensions: [".zig", ".zon"],
 	root: createRootDetector(["build.zig"]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"zig",
-			"zls",
-			[],
-			{ cwd: root },
-			async () => await launchLSP("zls", [], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "zig",
+	command: "zls",
+});
 
-export const HaskellServer: LSPServerInfo = {
+export const HaskellServer = createInteractiveServer({
 	id: "haskell",
 	name: "Haskell Language Server",
 	extensions: [".hs", ".lhs"],
 	root: createRootDetector(["stack.yaml", "cabal.project", "*.cabal"]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"haskell",
-			"haskell-language-server-wrapper",
-			["--lsp"],
-			{ cwd: root },
-			async () =>
-				await launchLSP("haskell-language-server-wrapper", ["--lsp"], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "haskell",
+	command: "haskell-language-server-wrapper",
+	args: ["--lsp"],
+});
 
-export const ElixirServer: LSPServerInfo = {
+export const ElixirServer = createInteractiveServer({
 	id: "elixir",
 	name: "ElixirLS",
 	extensions: [".ex", ".exs"],
 	root: createRootDetector(["mix.exs"]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"elixir",
-			"elixir-ls",
-			[],
-			{ cwd: root },
-			async () => await launchLSP("elixir-ls", [], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "elixir",
+	command: "elixir-ls",
+});
 
-export const GleamServer: LSPServerInfo = {
+export const GleamServer = createInteractiveServer({
 	id: "gleam",
 	name: "Gleam LSP",
 	extensions: [".gleam"],
 	root: createRootDetector(["gleam.toml"]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"gleam",
-			"gleam",
-			["lsp"],
-			{ cwd: root },
-			async () => await launchLSP("gleam", ["lsp"], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "gleam",
+	command: "gleam",
+	args: ["lsp"],
+});
 
-export const OCamlServer: LSPServerInfo = {
+export const OCamlServer = createInteractiveServer({
 	id: "ocaml",
 	name: "ocamllsp",
 	extensions: [".ml", ".mli"],
 	root: createRootDetector(["dune-project", "opam"]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"ocaml",
-			"ocamllsp",
-			[],
-			{ cwd: root },
-			async () => await launchLSP("ocamllsp", [], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "ocaml",
+	command: "ocamllsp",
+});
 
-export const ClojureServer: LSPServerInfo = {
+export const ClojureServer = createInteractiveServer({
 	id: "clojure",
 	name: "Clojure LSP",
 	extensions: [".clj", ".cljs", ".cljc", ".edn"],
 	root: createRootDetector(["deps.edn", "project.clj"]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"clojure",
-			"clojure-lsp",
-			[],
-			{ cwd: root },
-			async () => await launchLSP("clojure-lsp", [], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "clojure",
+	command: "clojure-lsp",
+});
 
-export const TerraformServer: LSPServerInfo = {
+export const TerraformServer = createInteractiveServer({
 	id: "terraform",
 	name: "Terraform LSP",
 	extensions: [".tf", ".tfvars"],
 	root: createRootDetector([".terraform.lock.hcl"]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"terraform",
-			"terraform-ls",
-			["serve"],
-			{ cwd: root },
-			async () => await launchLSP("terraform-ls", ["serve"], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "terraform",
+	command: "terraform-ls",
+	args: ["serve"],
+});
 
-export const NixServer: LSPServerInfo = {
+export const NixServer = createInteractiveServer({
 	id: "nix",
 	name: "nixd",
 	extensions: [".nix"],
 	root: createRootDetector(["flake.nix"]),
-	async spawn(root) {
-		const proc = await spawnWithInteractiveInstall(
-			"nix",
-			"nixd",
-			[],
-			{ cwd: root },
-			async () => await launchLSP("nixd", [], { cwd: root }),
-		);
-		return proc ? { process: proc } : undefined;
-	},
-};
+	language: "nix",
+	command: "nixd",
+});
 
 export const BashServer: LSPServerInfo = {
 	id: "bash",
 	name: "Bash Language Server",
 	extensions: [".sh", ".bash", ".zsh"],
+	installPolicy: "interactive",
 	root: async () => process.cwd(),
-	async spawn() {
+	async spawn(_root, options) {
 		const cwd = process.cwd();
 		const proc = await spawnWithInteractiveInstall(
 			"bash",
 			"bash-language-server",
 			["start"],
-			{ cwd },
+			{ cwd, allowInstall: options?.allowInstall },
 			async () => await launchLSP("bash-language-server", ["start"], {}),
 		);
 		return proc ? { process: proc } : undefined;
@@ -781,16 +858,18 @@ export const BashServer: LSPServerInfo = {
 export const DockerServer: LSPServerInfo = {
 	id: "docker",
 	name: "Dockerfile Language Server",
+	installPolicy: "package-manager",
 	extensions: [".dockerfile", "Dockerfile"],
-	root: async () => process.cwd(),
-	async spawn() {
-		// Use npx since it's not auto-installed
-		const proc = await launchViaPackageManager(
+	root: PriorityRoot([["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"], [".git"]]),
+	async spawn(_root, options) {
+		const launched = await launchWithDirectOrPackageManager(
+			nodeBinCandidates(process.cwd(), "docker-langserver"),
 			"dockerfile-language-server-nodejs",
 			["--stdio"],
-			{},
+			{ cwd: process.cwd(), allowInstall: options?.allowInstall },
 		);
-		return { process: proc };
+		if (!launched) return undefined;
+		return { process: launched.process, source: launched.source };
 	},
 };
 
@@ -798,14 +877,15 @@ export const YamlServer: LSPServerInfo = {
 	id: "yaml",
 	name: "YAML Language Server",
 	extensions: [".yaml", ".yml"],
-	root: async () => process.cwd(),
-	async spawn() {
+	installPolicy: "interactive",
+	root: PriorityRoot([[".yamllint", "yamllint.yml", "yamllint.yaml", "pyproject.toml"], [".git"]]),
+	async spawn(_root, options) {
 		const cwd = process.cwd();
 		const proc = await spawnWithInteractiveInstall(
 			"yaml",
 			"yaml-language-server",
 			["--stdio"],
-			{ cwd },
+			{ cwd, allowInstall: options?.allowInstall },
 			async () => await launchLSP("yaml-language-server", ["--stdio"], {}),
 		);
 		return proc ? { process: proc } : undefined;
@@ -816,14 +896,15 @@ export const JsonServer: LSPServerInfo = {
 	id: "json",
 	name: "VSCode JSON Language Server",
 	extensions: [".json", ".jsonc"],
-	root: async () => process.cwd(),
-	async spawn() {
+	installPolicy: "interactive",
+	root: PriorityRoot([["package.json", "tsconfig.json", "jsconfig.json"], [".git"]]),
+	async spawn(_root, options) {
 		const cwd = process.cwd();
 		const proc = await spawnWithInteractiveInstall(
 			"json",
 			"vscode-json-language-server",
 			["--stdio"],
-			{ cwd },
+			{ cwd, allowInstall: options?.allowInstall },
 			async () =>
 				await launchLSP("vscode-json-language-server", ["--stdio"], {}),
 		);
@@ -834,16 +915,18 @@ export const JsonServer: LSPServerInfo = {
 export const PrismaServer: LSPServerInfo = {
 	id: "prisma",
 	name: "Prisma Language Server",
+	installPolicy: "package-manager",
 	extensions: [".prisma"],
 	root: createRootDetector(["prisma/schema.prisma"]),
-	async spawn(root) {
-		// Use npx since it's not auto-installed
-		const proc = await launchViaPackageManager(
+	async spawn(root, options) {
+		const launched = await launchWithDirectOrPackageManager(
+			nodeBinCandidates(root, "prisma-language-server"),
 			"@prisma/language-server",
 			["--stdio"],
-			{ cwd: root },
+			{ cwd: root, allowInstall: options?.allowInstall },
 		);
-		return { process: proc };
+		if (!launched) return undefined;
+		return { process: launched.process, source: launched.source };
 	},
 };
 
@@ -853,6 +936,7 @@ export const VueServer: LSPServerInfo = {
 	id: "vue",
 	name: "Vue Language Server",
 	extensions: [".vue"],
+	installPolicy: "package-manager",
 	root: createRootDetector([
 		"package-lock.json",
 		"bun.lockb",
@@ -860,16 +944,15 @@ export const VueServer: LSPServerInfo = {
 		"pnpm-lock.yaml",
 		"yarn.lock",
 	]),
-	async spawn(root) {
-		// Use npx since it's not auto-installed
-		const proc = await launchViaPackageManager(
+	async spawn(root, options) {
+		const launched = await launchWithDirectOrPackageManager(
+			nodeBinCandidates(root, "vue-language-server"),
 			"@vue/language-server",
 			["--stdio"],
-			{
-				cwd: root,
-			},
+			{ cwd: root, allowInstall: options?.allowInstall },
 		);
-		return { process: proc };
+		if (!launched) return undefined;
+		return { process: launched.process, source: launched.source };
 	},
 };
 
@@ -877,6 +960,7 @@ export const SvelteServer: LSPServerInfo = {
 	id: "svelte",
 	name: "Svelte Language Server",
 	extensions: [".svelte"],
+	installPolicy: "package-manager",
 	root: createRootDetector([
 		"package-lock.json",
 		"bun.lockb",
@@ -884,20 +968,22 @@ export const SvelteServer: LSPServerInfo = {
 		"pnpm-lock.yaml",
 		"yarn.lock",
 	]),
-	async spawn(root) {
-		// Use npx since it's not auto-installed
-		const proc = await launchViaPackageManager(
+	async spawn(root, options) {
+		const launched = await launchWithDirectOrPackageManager(
+			[...nodeBinCandidates(root, "svelteserver"), ...nodeBinCandidates(root, "svelte-language-server")],
 			"svelte-language-server",
 			["--stdio"],
-			{ cwd: root },
+			{ cwd: root, allowInstall: options?.allowInstall },
 		);
-		return { process: proc };
+		if (!launched) return undefined;
+		return { process: launched.process, source: launched.source };
 	},
 };
 
 export const ESLintServer: LSPServerInfo = {
 	id: "eslint",
 	name: "ESLint Language Server",
+	installPolicy: "package-manager",
 	extensions: [".js", ".jsx", ".vue", ".svelte"], // Note: .ts/.tsx handled by TypeScript LSP + Biome
 	root: createRootDetector([
 		".eslintrc",
@@ -907,15 +993,17 @@ export const ESLintServer: LSPServerInfo = {
 		"eslint.config.mjs",
 		"package.json",
 	]),
-	async spawn(root) {
+	async spawn(root, options) {
 		// Try via package manager (npx) since it's not auto-installed
 		try {
-			const proc = await launchViaPackageManager(
+			const launched = await launchWithDirectOrPackageManager(
+				nodeBinCandidates(root, "vscode-eslint-language-server"),
 				"vscode-eslint-language-server",
 				["--stdio"],
-				{ cwd: root },
+				{ cwd: root, allowInstall: options?.allowInstall },
 			);
-			return { process: proc };
+			if (!launched) return undefined;
+			return { process: launched.process, source: launched.source };
 		} catch {
 			// Fall back to global install message
 			console.error(
@@ -929,16 +1017,18 @@ export const ESLintServer: LSPServerInfo = {
 export const CssServer: LSPServerInfo = {
 	id: "css",
 	name: "CSS Language Server",
+	installPolicy: "package-manager",
 	extensions: [".css", ".scss", ".sass", ".less"],
-	root: async () => process.cwd(),
-	async spawn() {
-		// Use npx since it's not auto-installed
-		const proc = await launchViaPackageManager(
+	root: PriorityRoot([["package.json", "postcss.config.js", "tailwind.config.js", "vite.config.ts"], [".git"]]),
+	async spawn(_root, options) {
+		const launched = await launchWithDirectOrPackageManager(
+			nodeBinCandidates(process.cwd(), "vscode-css-language-server"),
 			"vscode-css-languageserver",
 			["--stdio"],
-			{},
+			{ cwd: process.cwd(), allowInstall: options?.allowInstall },
 		);
-		return { process: proc };
+		if (!launched) return undefined;
+		return { process: launched.process, source: launched.source };
 	},
 };