lazycodex-ai 5.1.48 → 5.1.51

package/packages/lsp-core/src/lsp/process.ts

@@ -0,0 +1,221 @@
+import { type ChildProcess, spawn, spawnSync } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import { delimiter, join } from "node:path";
+
+import { reportBestEffortCleanupError } from "./cleanup-errors.js";
+import { LspInvalidPathError, LspProcessSpawnError } from "./errors.js";
+
+export interface SpawnedProcess {
+	stdin: NodeJS.WritableStream;
+	stdout: NodeJS.ReadableStream;
+	stderr: NodeJS.ReadableStream;
+	pid: number | undefined;
+	exitCode: number | null;
+	exited: Promise<number>;
+	kill(signal?: NodeJS.Signals): void;
+	killed: boolean;
+}
+
+export interface SpawnOptions {
+	cwd: string;
+	env: Record<string, string | undefined>;
+}
+
+export interface PreparedSpawnCommand {
+	command: string;
+	args: string[];
+	shell: false;
+}
+
+function isMissingProcessError(error: unknown): boolean {
+	if (!(error instanceof Error) || !("code" in error)) return false;
+	return error.code === "ESRCH";
+}
+
+function reportKillError(context: string, error: unknown): void {
+	if (!isMissingProcessError(error)) {
+		reportBestEffortCleanupError(context, error);
+	}
+}
+
+export function validateCwd(cwd: string): { valid: boolean; error?: string } {
+	try {
+		if (!existsSync(cwd)) {
+			return { valid: false, error: `Working directory does not exist: ${cwd}` };
+		}
+		const stats = statSync(cwd);
+		if (!stats.isDirectory()) {
+			return { valid: false, error: `Path is not a directory: ${cwd}` };
+		}
+		return { valid: true };
+	} catch (err) {
+		return {
+			valid: false,
+			error: `Cannot access working directory: ${cwd} (${err instanceof Error ? err.message : String(err)})`,
+		};
+	}
+}
+
+// The child's pipes outlive every JsonRpcConnection that borrows them: a
+// connection detaches its listeners on dispose, yet a write issued before
+// dispose can still fail later (on Windows a closed pipe reports EPIPE
+// asynchronously). An 'error' event with no listener is raised as an unhandled
+// error, so each pipe keeps this guard for its whole life. It reports only when
+// no other owner is listening, so an attached connection keeps sole reporting.
+function guardPipeErrors(stream: NodeJS.EventEmitter, pipe: string): void {
+	stream.on("error", (error: Error) => {
+		if (stream.listenerCount("error") > 1) return;
+		reportBestEffortCleanupError(`server ${pipe}`, error);
+	});
+}
+
+function wrap(proc: ChildProcess): SpawnedProcess {
+	const exitedPromise = new Promise<number>((resolve) => {
+		proc.once("close", (code) => resolve(code ?? 0));
+		proc.once("error", () => resolve(1));
+	});
+
+	if (!proc.stdin || !proc.stdout || !proc.stderr) {
+		throw new LspProcessSpawnError("Spawned process is missing one of stdin/stdout/stderr pipes");
+	}
+	guardPipeErrors(proc.stdin, "stdin");
+	guardPipeErrors(proc.stdout, "stdout");
+	guardPipeErrors(proc.stderr, "stderr");
+
+	return {
+		stdin: proc.stdin,
+		stdout: proc.stdout,
+		stderr: proc.stderr,
+		get pid() {
+			return proc.pid ?? undefined;
+		},
+		get exitCode() {
+			return proc.exitCode;
+		},
+		get killed() {
+			return proc.killed;
+		},
+		exited: exitedPromise,
+		kill(signal?: NodeJS.Signals) {
+			killProcessTree(proc, signal ?? "SIGTERM");
+		},
+	};
+}
+
+export function killProcessTree(proc: ChildProcess, signal: NodeJS.Signals): void {
+	if (process.platform === "win32" && proc.pid) {
+		const result = spawnSync("taskkill", ["/pid", String(proc.pid), "/f", "/t"], {
+			stdio: "ignore",
+			windowsHide: true,
+		});
+		if (!result.error && result.status === 0) return;
+		if (result.error) reportKillError("windows process tree kill", result.error);
+	}
+
+	if (process.platform !== "win32" && proc.pid) {
+		try {
+			process.kill(-proc.pid, signal);
+			return;
+		} catch (error) {
+			reportKillError("process group kill", error);
+		}
+	}
+
+	try {
+		proc.kill(signal);
+	} catch (error) {
+		reportKillError("process kill", error);
+	}
+}
+
+function isWindowsShellShim(command: string): boolean {
+	const lowerCommand = command.toLowerCase();
+	return lowerCommand.endsWith(".cmd") || lowerCommand.endsWith(".bat");
+}
+
+function splitPath(pathValue: string, platform: NodeJS.Platform): string[] {
+	const separator = platform === "win32" ? ";" : delimiter;
+	return pathValue.split(separator).filter(Boolean);
+}
+
+function getWindowsPathExtensions(env: Record<string, string | undefined>): string[] {
+	const rawExtensions = env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD";
+	const extensions = rawExtensions
+		.split(";")
+		.map((extension) => extension.trim())
+		.filter(Boolean)
+		.map((extension) => (extension.startsWith(".") ? extension : `.${extension}`));
+	return [...new Set([...extensions, ".exe", ".cmd", ".bat", ""])];
+}
+
+function resolveWindowsCommand(command: string, env: Record<string, string | undefined>): string {
+	const hasPathSeparator = command.includes("/") || command.includes("\\");
+	const pathValue = env["PATH"] ?? env["Path"] ?? "";
+	const baseDirectories = hasPathSeparator ? [""] : splitPath(pathValue, "win32");
+	const extensions = getWindowsPathExtensions(env);
+
+	for (const baseDirectory of baseDirectories) {
+		for (const extension of extensions) {
+			const candidate = baseDirectory ? join(baseDirectory, `${command}${extension}`) : `${command}${extension}`;
+			if (existsSync(candidate)) return candidate;
+		}
+	}
+
+	return command;
+}
+
+export function createSpawnCommand(
+	command: string[],
+	platform: NodeJS.Platform = process.platform,
+	commandProcessor: string = process.env["ComSpec"] ?? "cmd.exe",
+	env: Record<string, string | undefined> = process.env,
+): PreparedSpawnCommand {
+	const [cmd, ...args] = command;
+	if (!cmd) {
+		throw new LspProcessSpawnError("[lsp] empty command");
+	}
+
+	if (platform !== "win32") {
+		return { command: cmd, args, shell: false };
+	}
+
+	const resolvedCommand = resolveWindowsCommand(cmd, env);
+	if (!isWindowsShellShim(resolvedCommand)) {
+		return { command: resolvedCommand, args, shell: false };
+	}
+
+	return {
+		command: commandProcessor,
+		args: ["/d", "/s", "/c", resolvedCommand, ...args],
+		shell: false,
+	};
+}
+
+export function spawnProcess(command: string[], options: SpawnOptions): SpawnedProcess {
+	const cwdValidation = validateCwd(options.cwd);
+	if (!cwdValidation.valid) {
+		throw new LspInvalidPathError(`[lsp] ${cwdValidation.error}`);
+	}
+
+	const [cmd] = command;
+	if (!cmd) {
+		throw new LspProcessSpawnError("[lsp] empty command");
+	}
+
+	const preparedCommand = createSpawnCommand(
+		command,
+		process.platform,
+		process.env["ComSpec"] ?? "cmd.exe",
+		options.env,
+	);
+	const proc = spawn(preparedCommand.command, preparedCommand.args, {
+		cwd: options.cwd,
+		env: options.env,
+		stdio: ["pipe", "pipe", "pipe"],
+		windowsHide: true,
+		shell: preparedCommand.shell,
+		detached: process.platform !== "win32",
+	});
+
+	return wrap(proc);
+}

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

@@ -0,0 +1,205 @@
+import type { LspServerConfig } from "./types.js";
+
+export const LSP_INSTALL_HINTS: Record<string, string> = {
+	typescript: "npm install -g typescript-language-server typescript",
+	deno: "Install Deno from https://deno.land",
+	vue: "npm install -g @vue/language-server",
+	eslint: "npm install -g vscode-langservers-extracted",
+	oxlint: "npm install -g oxlint",
+	biome: "npm install -g @biomejs/biome",
+	gopls: "go install golang.org/x/tools/gopls@latest",
+	"ruby-lsp": "gem install ruby-lsp",
+	basedpyright: "pip install basedpyright",
+	pyright: "pip install pyright",
+	ty: "pip install ty",
+	ruff: "pip install ruff",
+	"elixir-ls": "See https://github.com/elixir-lsp/elixir-ls",
+	zls: "See https://github.com/zigtools/zls",
+	csharp: "dotnet tool install -g csharp-ls",
+	fsharp: "dotnet tool install -g fsautocomplete",
+	"sourcekit-lsp": "Included with Xcode or Swift toolchain",
+	rust:
+		"Install rust-analyzer and ensure it is in PATH. If using rustup: rustup component add rust-analyzer. " +
+		"If rust-analyzer exits while loading rust-src: rustup component remove rust-src && rustup component add rust-src.",
+	clangd: "See https://clangd.llvm.org/installation",
+	svelte: "npm install -g svelte-language-server",
+	astro: "npm install -g @astrojs/language-server",
+	"bash-ls": "npm install -g bash-language-server",
+	jdtls: "See https://github.com/eclipse-jdtls/eclipse.jdt.ls",
+	"yaml-ls": "npm install -g yaml-language-server",
+	"lua-ls": "See https://github.com/LuaLS/lua-language-server",
+	php: "npm install -g intelephense",
+	dart: "Included with Dart SDK",
+	"terraform-ls": "See https://github.com/hashicorp/terraform-ls",
+	terraform: "See https://github.com/hashicorp/terraform-ls",
+	prisma: "npm install -g prisma",
+	"ocaml-lsp": "opam install ocaml-lsp-server",
+	texlab: "See https://github.com/latex-lsp/texlab",
+	dockerfile: "npm install -g dockerfile-language-server-nodejs",
+	gleam: "See https://gleam.run/getting-started/installing/",
+	"clojure-lsp": "See https://clojure-lsp.io/installation/",
+	nixd: "nix profile install nixpkgs#nixd",
+	tinymist: "See https://github.com/Myriad-Dreamin/tinymist",
+	"haskell-language-server": "ghcup install hls",
+	bash: "npm install -g bash-language-server",
+	"kotlin-ls": "See https://github.com/Kotlin/kotlin-lsp",
+	julials: "julia -e 'using Pkg; Pkg.add(\"LanguageServer\")'",
+	razor:
+		"Razor runs through the Roslyn language server (cohosting). " +
+		"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"],
+		extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+	},
+	deno: { command: ["deno", "lsp"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs"] },
+	vue: { command: ["vue-language-server", "--stdio"], extensions: [".vue"] },
+	eslint: {
+		command: ["vscode-eslint-language-server", "--stdio"],
+		extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".vue"],
+	},
+	oxlint: {
+		command: ["oxlint", "--lsp"],
+		extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".vue", ".astro", ".svelte"],
+	},
+	biome: {
+		command: ["biome", "lsp-proxy", "--stdio"],
+		extensions: [
+			".ts",
+			".tsx",
+			".js",
+			".jsx",
+			".mjs",
+			".cjs",
+			".mts",
+			".cts",
+			".json",
+			".jsonc",
+			".vue",
+			".astro",
+			".svelte",
+			".css",
+			".graphql",
+			".gql",
+			".html",
+		],
+	},
+	gopls: { command: ["gopls"], extensions: [".go"] },
+	"ruby-lsp": {
+		command: ["rubocop", "--lsp"],
+		extensions: [".rb", ".rake", ".gemspec", ".ru"],
+	},
+	basedpyright: {
+		command: ["basedpyright-langserver", "--stdio"],
+		extensions: [".py", ".pyi"],
+	},
+	pyright: { command: ["pyright-langserver", "--stdio"], extensions: [".py", ".pyi"] },
+	ty: { command: ["ty", "server"], extensions: [".py", ".pyi"] },
+	ruff: { command: ["ruff", "server"], extensions: [".py", ".pyi"] },
+	"elixir-ls": { command: ["elixir-ls"], extensions: [".ex", ".exs"] },
+	zls: { command: ["zls"], extensions: [".zig", ".zon"] },
+	csharp: { command: ["csharp-ls"], extensions: [".cs"] },
+	fsharp: { command: ["fsautocomplete"], extensions: [".fs", ".fsi", ".fsx", ".fsscript"] },
+	"sourcekit-lsp": { command: ["sourcekit-lsp"], extensions: [".swift", ".m", ".mm"] },
+	rust: { command: ["rust-analyzer"], extensions: [".rs"] },
+	clangd: {
+		command: ["clangd", "--background-index", "--clang-tidy"],
+		extensions: [".c", ".cpp", ".cc", ".cxx", ".c++", ".h", ".hpp", ".hh", ".hxx", ".h++"],
+	},
+	svelte: { command: ["svelteserver", "--stdio"], extensions: [".svelte"] },
+	astro: { command: ["astro-ls", "--stdio"], extensions: [".astro"] },
+	bash: {
+		command: ["bash-language-server", "start"],
+		extensions: [".sh", ".bash", ".zsh", ".ksh"],
+	},
+	"bash-ls": {
+		command: ["bash-language-server", "start"],
+		extensions: [".sh", ".bash", ".zsh", ".ksh"],
+	},
+	jdtls: { command: ["jdtls"], extensions: [".java"] },
+	"yaml-ls": { command: ["yaml-language-server", "--stdio"], extensions: [".yaml", ".yml"] },
+	"lua-ls": { command: ["lua-language-server"], extensions: [".lua"] },
+	php: { command: ["intelephense", "--stdio"], extensions: [".php"] },
+	dart: { command: ["dart", "language-server", "--lsp"], extensions: [".dart"] },
+	terraform: { command: ["terraform-ls", "serve"], extensions: [".tf", ".tfvars"] },
+	"terraform-ls": { command: ["terraform-ls", "serve"], extensions: [".tf", ".tfvars"] },
+	prisma: { command: ["prisma", "language-server"], extensions: [".prisma"] },
+	"ocaml-lsp": { command: ["ocamllsp"], extensions: [".ml", ".mli"] },
+	texlab: { command: ["texlab"], extensions: [".tex", ".bib"] },
+	dockerfile: { command: ["docker-langserver", "--stdio"], extensions: [".dockerfile"] },
+	gleam: { command: ["gleam", "lsp"], extensions: [".gleam"] },
+	"clojure-lsp": {
+		command: ["clojure-lsp", "listen"],
+		extensions: [".clj", ".cljs", ".cljc", ".edn"],
+	},
+	nixd: { command: ["nixd"], extensions: [".nix"] },
+	tinymist: { command: ["tinymist"], extensions: [".typ", ".typc"] },
+	"haskell-language-server": {
+		command: ["haskell-language-server-wrapper", "--lsp"],
+		extensions: [".hs", ".lhs"],
+	},
+	"kotlin-ls": { command: ["kotlin-lsp", "--stdio"], extensions: [".kt", ".kts"] },
+	julials: {
+		command: ["julia", "--startup-file=no", "--history-file=no", "-e", "using LanguageServer; runserver()"],
+		extensions: [".jl"],
+	},
+	razor: {
+		command: ["roslyn-language-server", "--stdio"],
+		extensions: [".razor", ".cshtml"],
+	},
+};
+
+export const AUTO_INSTALLABLE_SERVERS: Record<string, string[]> = {
+	typescript: ["npm", "install", "-g", "typescript-language-server", "typescript"],
+	vue: ["npm", "install", "-g", "@vue/language-server"],
+	eslint: ["npm", "install", "-g", "vscode-langservers-extracted"],
+	oxlint: ["npm", "install", "-g", "oxlint"],
+	biome: ["npm", "install", "-g", "@biomejs/biome"],
+	svelte: ["npm", "install", "-g", "svelte-language-server"],
+	astro: ["npm", "install", "-g", "@astrojs/language-server"],
+	"bash-ls": ["npm", "install", "-g", "bash-language-server"],
+	bash: ["npm", "install", "-g", "bash-language-server"],
+	"yaml-ls": ["npm", "install", "-g", "yaml-language-server"],
+	php: ["npm", "install", "-g", "intelephense"],
+	prisma: ["npm", "install", "-g", "prisma"],
+	dockerfile: ["npm", "install", "-g", "dockerfile-language-server-nodejs"],
+	gopls: ["go", "install", "golang.org/x/tools/gopls@latest"],
+	pyright: ["pip", "install", "pyright"],
+	basedpyright: ["pip", "install", "basedpyright"],
+	ruff: ["pip", "install", "ruff"],
+	ty: ["pip", "install", "ty"],
+	"ruby-lsp": ["gem", "install", "ruby-lsp"],
+	"ocaml-lsp": ["opam", "install", "ocaml-lsp-server"],
+	julials: ["julia", "-e", 'using Pkg; Pkg.add("LanguageServer")'],
+};

package/packages/lsp-core/src/lsp/server-install-state.ts

@@ -0,0 +1,67 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+import { lspRequestContext } from "../request-context.js";
+
+export type InstallDecision = "declined" | "allowed";
+
+export interface InstallDecisionRecord {
+	readonly decision: InstallDecision;
+	readonly decidedAt: string;
+}
+
+type InstallDecisions = Record<string, InstallDecisionRecord>;
+
+export function getInstallDecisionsPath(): string {
+	return lspRequestContext().installDecisionsPath;
+}
+
+export function loadInstallDecisions(): InstallDecisions {
+	const path = getInstallDecisionsPath();
+	if (!existsSync(path)) return {};
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+		return isInstallDecisions(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+
+export function loadInstallDecision(serverId: string): InstallDecisionRecord | undefined {
+	return loadInstallDecisions()[serverId];
+}
+
+export function recordInstallDecision(
+	serverId: string,
+	decision: InstallDecision,
+	decidedAt: string = new Date().toISOString(),
+): void {
+	const decisions = loadInstallDecisions();
+	decisions[serverId] = { decision, decidedAt };
+	writeInstallDecisions(decisions);
+}
+
+export function isInstallDecision(value: unknown): value is InstallDecision {
+	return value === "declined" || value === "allowed";
+}
+
+function writeInstallDecisions(decisions: InstallDecisions): void {
+	const path = getInstallDecisionsPath();
+	mkdirSync(dirname(path), { recursive: true });
+	const tmpPath = `${path}.tmp`;
+	writeFileSync(tmpPath, `${JSON.stringify(decisions, null, 2)}\n`, "utf8");
+	renameSync(tmpPath, path);
+}
+
+function isInstallDecisions(value: unknown): value is InstallDecisions {
+	return isRecord(value) && Object.values(value).every(isInstallDecisionRecord);
+}
+
+function isInstallDecisionRecord(value: unknown): value is InstallDecisionRecord {
+	if (!isRecord(value)) return false;
+	return isInstallDecision(value["decision"]) && typeof value["decidedAt"] === "string";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}