import { constants } from "node:fs"; import { access, stat } from "node:fs/promises"; import { basename, delimiter, dirname, extname, isAbsolute, relative, resolve, } from "node:path"; import { fileURLToPath } from "node:url"; import { LspFailure, snapshot } from "./source.ts"; export interface Profile { id: string; command: string; args: string[]; language: string; extensions?: string[]; roots?: string[]; provenance?: Record; initializationOptions: Record; settings: Record; } export async function profile( file?: string, server?: string, ): Promise { try { const path = fileURLToPath( new URL( import.meta.url.endsWith("/src/registry.ts") ? "../registry/servers.json" : "./registry/servers.json", import.meta.url, ), ); const value = JSON.parse(await snapshot(path)); if ( value.schemaVersion !== 1 || !Array.isArray(value.profiles) || value.profiles.length < 1 || value.profiles.length > 16 ) throw new Error("Invalid registry"); const ids = new Set(); for (const p of value.profiles) { if ( !p || typeof p.id !== "string" || !/^[a-z0-9-]{1,64}$/u.test(p.id) || ids.has(p.id) || typeof p.command !== "string" || !/^[a-zA-Z0-9_-]{1,128}$/u.test(p.command) || !Array.isArray(p.args) || p.args.length > 32 || p.args.some((a: unknown) => typeof a !== "string" || a.length > 4096) || typeof p.language !== "string" || !Array.isArray(p.extensions) || !p.extensions.length || p.extensions.length > 32 || p.extensions.some( (e: unknown) => typeof e !== "string" || !/^\.[a-zA-Z0-9]+$/u.test(e), ) || !Array.isArray(p.roots) || p.roots.length > 32 || p.roots.some( (r: unknown) => typeof r !== "string" || !/^[a-zA-Z0-9_.-]{1,128}$/u.test(r), ) || !p.initializationOptions || typeof p.initializationOptions !== "object" || Array.isArray(p.initializationOptions) || !p.settings || typeof p.settings !== "object" || Array.isArray(p.settings) || !p.provenance ) throw new Error("Invalid profile"); ids.add(p.id); } const matches = (value.profiles as Profile[]).filter( (p) => (!server || p.id === server) && (!file || p.extensions?.includes(extname(file))), ); if (matches.length !== 1) throw new LspFailure( matches.length ? "ambiguous" : "unsupported", matches.length ? "Specify server: " + matches.map((p) => p.id).join(", ") : "No packaged server profile matches file/server selector.", ); return matches[0] as Profile; } catch (error) { if (error instanceof LspFailure) throw error; throw new LspFailure( "invalid_config", "Invalid or unavailable packaged server registry; rebuild/reinstall package.", ); } } export interface LaunchDescriptor { command: string; args: string[]; identity: string; } interface ExecutableOptions { platform?: NodeJS.Platform; path?: string; } async function regularReadable( path: string, mode = constants.R_OK, ): Promise { try { if (!(await stat(path)).isFile()) return false; await access(path, mode); return true; } catch { return false; } } function packagePath(directory: string, bin: string): string | undefined { if ( typeof bin !== "string" || bin.length < 1 || bin.length > 4096 || isAbsolute(bin) ) return undefined; const path = resolve(directory, bin); const rel = relative(directory, path); return rel && rel !== ".." && !rel.startsWith("../") && !rel.startsWith("..\\") && !isAbsolute(rel) ? path : undefined; } async function npmShim( directory: string, shim: string, ): Promise { const packageDirs = basename(directory) === ".bin" && basename(dirname(directory)) === "node_modules" ? [resolve(directory, "..", "typescript-language-server")] : [resolve(directory, "node_modules", "typescript-language-server")]; for (const packageDir of packageDirs) { const manifest = resolve(packageDir, "package.json"); try { const value: unknown = JSON.parse(await snapshot(manifest)); if (!value || typeof value !== "object" || Array.isArray(value)) continue; const record = value as { name?: unknown; bin?: unknown }; const bin = typeof record.bin === "string" ? record.bin : record.bin && typeof record.bin === "object" && !Array.isArray(record.bin) ? (record.bin as Record)[ "typescript-language-server" ] : undefined; const script = packagePath(packageDir, bin as string); if ( record.name !== "typescript-language-server" || !script || !(await regularReadable(script)) ) throw new Error("invalid npm shim metadata"); return { command: process.execPath, args: [script], identity: `${shim}:${script}`, }; } catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") continue; throw error; } } return undefined; } export async function executable( command: string, options: ExecutableOptions = {}, ): Promise { const platform = options.platform ?? process.platform; const path = options.path ?? Object.entries(process.env).find( ([key]) => key.toLowerCase() === "path", )?.[1] ?? ""; const separator = platform === "win32" ? ";" : delimiter; for (const dir of path.split(separator).filter(Boolean).slice(0, 128)) { const native = resolve( dir, platform === "win32" ? `${command}.exe` : command, ); if ( await regularReadable( native, platform === "win32" ? constants.R_OK : constants.R_OK | constants.X_OK, ) ) return { command: native, args: [], identity: native }; if (platform !== "win32" || command !== "typescript-language-server") continue; const shim = resolve(dir, "typescript-language-server.cmd"); if (!(await regularReadable(shim))) continue; try { const launch = await npmShim(dir, shim); if (launch) return launch; } catch { throw new LspFailure( "missing_tool", "typescript-language-server.cmd has invalid npm metadata; repair it yourself, then retry; no auto-repair is performed.", ); } throw new LspFailure( "missing_tool", "typescript-language-server.cmd has no adjacent readable npm package; repair it yourself, then retry; no auto-repair is performed.", ); } throw new LspFailure( "missing_tool", `${command} not found on PATH. Install ${command} yourself, then retry; no auto-install is performed.`, ); }