pi-lsp-adapter 0.1.0

package/src/install/installers.ts

@@ -0,0 +1,513 @@
+import { constants } from "node:fs";
+import { access, chmod, copyFile, mkdir, rm, symlink, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { getBinDir, getLogsDir, getPackagesDir } from "../config/paths.js";
+import { messageFromError, normalizeProcessEnv } from "../util/helpers.js";
+import type {
+  GithubInstallSpec,
+  GoInstallSpec,
+  InstalledServerMetadata,
+  NpmInstallSpec,
+  ServerDefinition,
+  SystemInstallSpec,
+} from "../registry/schema.js";
+import { ConfigError, MissingBinaryError } from "../util/errors.js";
+import { createInstalledServerMetadata, ensureManagedLspRoot } from "./lockfile.js";
+
+export interface CommandInvocation {
+  command: string;
+  args: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+}
+
+export interface CommandResult {
+  code: number;
+  stdout: string;
+  stderr: string;
+}
+
+export type CommandRunner = (invocation: CommandInvocation) => Promise<CommandResult>;
+export type DownloadFile = (url: string, destinationPath: string) => Promise<void>;
+
+export interface InstallerOptions {
+  runner?: CommandRunner;
+  downloadFile?: DownloadFile;
+  env?: Record<string, string>;
+  now?: Date;
+}
+
+export interface InstallerResult {
+  metadata: InstalledServerMetadata;
+  logPath: string;
+}
+
+export async function installServerBackend(
+  server: ServerDefinition,
+  requestedVersion?: string,
+  options: InstallerOptions = {},
+): Promise<InstallerResult> {
+  await ensureManagedLspRoot();
+
+  try {
+    const result =
+      (await trySystemInstall(server, requestedVersion, options)) ??
+      (await installByType(server, requestedVersion, options));
+    await writeInstallLog(
+      server.id,
+      formatInstallLog([`Installed ${server.id}.`, `Command: ${result.metadata.resolvedCommand.join(" ")}`]),
+    );
+    return result;
+  } catch (error) {
+    await writeInstallLog(server.id, formatInstallLog([`Failed to install ${server.id}.`, messageFromError(error)]));
+    throw error;
+  }
+}
+
+export function buildNpmInstallCommand(
+  serverId: string,
+  install: NpmInstallSpec,
+  requestedVersion?: string,
+  env?: Record<string, string>,
+): CommandInvocation {
+  const packageDir = getServerPackageDir(serverId);
+  const packages = resolveNpmPackages(install.packages, requestedVersion);
+  const invocation: CommandInvocation = {
+    command: "npm",
+    args: [
+      "install",
+      "--prefix",
+      packageDir,
+      "--ignore-scripts",
+      "--no-audit",
+      "--fund=false",
+      ...Object.entries(packages).map(([name, version]) => `${name}@${version}`),
+    ],
+  };
+  if (env) invocation.env = env;
+  return invocation;
+}
+
+export function buildGoInstallCommand(
+  _serverId: string,
+  install: GoInstallSpec,
+  requestedVersion?: string,
+  env: Record<string, string> = normalizeProcessEnv(process.env),
+): CommandInvocation {
+  const version = requestedVersion ?? install.version ?? "latest";
+  return {
+    command: "go",
+    args: ["install", `${install.module}@${version}`],
+    env: { ...env, GOBIN: getBinDir() },
+  };
+}
+
+export async function writeInstallLog(serverId: string, content: string): Promise<string> {
+  const logPath = getInstallLogPath(serverId);
+  await mkdir(dirname(logPath), { recursive: true });
+  await writeFile(logPath, content, "utf8");
+  return logPath;
+}
+
+export function getInstallLogPath(serverId: string): string {
+  return join(getLogsDir(), `${serverId}-install.log`);
+}
+
+export function getServerPackageDir(serverId: string): string {
+  return join(getPackagesDir(), serverId);
+}
+
+export async function resolveSystemCommand(
+  server: ServerDefinition,
+  install: SystemInstallSpec,
+  env: Record<string, string> = normalizeProcessEnv(process.env),
+): Promise<string[]> {
+  const command = install.command ?? (install.bin ? [install.bin] : server.command);
+  if (command.length === 0) {
+    throw new MissingBinaryError(server.id, "<empty command>");
+  }
+
+  const executable = await resolveExecutable(command[0]!, env, server.id);
+  return [executable, ...command.slice(1)];
+}
+
+async function trySystemInstall(
+  server: ServerDefinition,
+  requestedVersion: string | undefined,
+  options: InstallerOptions,
+): Promise<InstallerResult | undefined> {
+  if (requestedVersion || server.install.type === "system") return undefined;
+
+  try {
+    return await installSystemServer(server, buildSystemFallbackInstall(server), undefined, options);
+  } catch (error) {
+    if (error instanceof MissingBinaryError) return undefined;
+    throw error;
+  }
+}
+
+function buildSystemFallbackInstall(server: ServerDefinition): SystemInstallSpec {
+  const bin = getInstallBinName(server);
+  return { type: "system", command: [bin, ...systemFallbackArgs(server)] };
+}
+
+export function getInstallBinName(server: ServerDefinition): string {
+  switch (server.install.type) {
+    case "npm":
+    case "go":
+    case "github":
+      return server.install.bin;
+    case "system":
+      return server.install.bin ?? server.install.command?.[0] ?? server.command[0] ?? server.id;
+  }
+}
+
+function systemFallbackArgs(server: ServerDefinition): string[] {
+  const command = server.command[0];
+  return command?.includes("{installBin}") ? commandArgsFromServerTemplate(server.command) : [];
+}
+
+async function installByType(
+  server: ServerDefinition,
+  requestedVersion: string | undefined,
+  options: InstallerOptions,
+): Promise<InstallerResult> {
+  switch (server.install.type) {
+    case "npm":
+      return installNpmServer(server, server.install, requestedVersion, options);
+    case "go":
+      return installGoServer(server, server.install, requestedVersion, options);
+    case "github":
+      return installGithubServer(server, server.install, requestedVersion, options);
+    case "system":
+      return installSystemServer(server, server.install, requestedVersion, options);
+  }
+}
+
+async function installNpmServer(
+  server: ServerDefinition,
+  install: NpmInstallSpec,
+  requestedVersion: string | undefined,
+  options: InstallerOptions,
+): Promise<InstallerResult> {
+  const runner = options.runner ?? defaultCommandRunner;
+  const packageDir = getServerPackageDir(server.id);
+  const command = buildNpmInstallCommand(server.id, install, requestedVersion, options.env);
+  await mkdir(packageDir, { recursive: true });
+  await runChecked(runner, command);
+
+  const packageBin = join(packageDir, "node_modules", ".bin", install.bin);
+  const resolvedBin = join(getBinDir(), install.bin);
+  await linkExecutable(packageBin, resolvedBin, server.id);
+
+  return {
+    metadata: createInstalledServerMetadata({
+      installer: "npm",
+      requestedVersion,
+      packages: resolveNpmPackages(install.packages, requestedVersion),
+      resolvedCommand: [resolvedBin, ...commandArgsFromServerTemplate(server.command)],
+      packageDir,
+      binDir: getBinDir(),
+      installedAt: options.now,
+    }),
+    logPath: getInstallLogPath(server.id),
+  };
+}
+
+async function installGoServer(
+  server: ServerDefinition,
+  install: GoInstallSpec,
+  requestedVersion: string | undefined,
+  options: InstallerOptions,
+): Promise<InstallerResult> {
+  const runner = options.runner ?? defaultCommandRunner;
+  const command = buildGoInstallCommand(server.id, install, requestedVersion, options.env);
+  await runChecked(runner, command);
+
+  return {
+    metadata: createInstalledServerMetadata({
+      installer: "go",
+      requestedVersion: requestedVersion ?? install.version,
+      resolvedCommand: [join(getBinDir(), install.bin)],
+      binDir: getBinDir(),
+      installedAt: options.now,
+    }),
+    logPath: getInstallLogPath(server.id),
+  };
+}
+
+async function installGithubServer(
+  server: ServerDefinition,
+  install: GithubInstallSpec,
+  requestedVersion: string | undefined,
+  options: InstallerOptions,
+): Promise<InstallerResult> {
+  const runner = options.runner ?? defaultCommandRunner;
+  const downloadFile = options.downloadFile ?? defaultDownloadFile;
+  const assetName = resolveGithubAssetName(install, requestedVersion);
+  const url = buildGithubAssetUrl(install, assetName, requestedVersion ?? install.version);
+  const packageDir = getServerPackageDir(server.id);
+  const archivePath = join(tmpdir(), `pi-lsp-${server.id}-${process.pid}-${Date.now()}-${basename(assetName)}`);
+  await mkdir(packageDir, { recursive: true });
+  await downloadFile(url, archivePath);
+
+  const extractedPath = await extractGithubAsset(runner, archivePath, packageDir, install.stripComponents ?? 0);
+  const needsManagedBin = commandUsesInstallBin(server.command);
+  const resolvedBin = join(getBinDir(), install.bin);
+  const resolvedCommand = needsManagedBin
+    ? [resolvedBin, ...commandArgsFromServerTemplate(server.command)]
+    : server.command;
+
+  if (needsManagedBin) {
+    const packageBin = await prepareGithubExecutable(packageDir, install.bin, extractedPath, server.id);
+    await linkExecutable(packageBin, resolvedBin, server.id);
+  }
+
+  return {
+    metadata: createInstalledServerMetadata({
+      installer: "github",
+      requestedVersion: requestedVersion ?? install.version,
+      resolvedCommand,
+      packageDir,
+      binDir: needsManagedBin ? getBinDir() : undefined,
+      installedAt: options.now,
+    }),
+    logPath: getInstallLogPath(server.id),
+  };
+}
+
+async function installSystemServer(
+  server: ServerDefinition,
+  install: SystemInstallSpec,
+  requestedVersion: string | undefined,
+  options: InstallerOptions,
+): Promise<InstallerResult> {
+  const resolvedCommand = await resolveSystemCommand(server, install, options.env ?? normalizeProcessEnv(process.env));
+  return {
+    metadata: createInstalledServerMetadata({
+      installer: "system",
+      requestedVersion,
+      resolvedCommand,
+      installedAt: options.now,
+    }),
+    logPath: getInstallLogPath(server.id),
+  };
+}
+
+async function runChecked(runner: CommandRunner, invocation: CommandInvocation): Promise<CommandResult> {
+  const result = await runner(invocation);
+  if (result.code !== 0) {
+    throw new ConfigError(
+      `${invocation.command} ${invocation.args.join(" ")} failed with exit code ${result.code}: ${tail(result.stderr || result.stdout)}`,
+    );
+  }
+  return result;
+}
+
+function resolveNpmPackages(
+  packages: Record<string, string>,
+  requestedVersion: string | undefined,
+): Record<string, string> {
+  const entries = Object.entries(packages);
+  if (!requestedVersion || entries.length === 0) {
+    return { ...packages };
+  }
+
+  const [primaryName] = entries[0]!;
+  return { ...packages, [primaryName]: requestedVersion };
+}
+
+function commandArgsFromServerTemplate(command: string[]): string[] {
+  return command.slice(1).filter((arg) => !arg.includes("{installBin}") && !arg.includes("{installDir}"));
+}
+
+function commandUsesInstallBin(command: string[]): boolean {
+  return command.some((part) => part.includes("{installBin}"));
+}
+
+async function linkExecutable(target: string, linkPath: string, serverId: string): Promise<void> {
+  await assertExecutable(target, target, serverId);
+  await mkdir(dirname(linkPath), { recursive: true });
+  await rm(linkPath, { force: true });
+  try {
+    await symlink(target, linkPath);
+  } catch {
+    await copyFile(target, linkPath);
+    await chmod(linkPath, 0o755).catch(() => undefined);
+  }
+}
+
+async function prepareGithubExecutable(
+  packageDir: string,
+  binName: string,
+  extractedPath: string | undefined,
+  serverId: string,
+): Promise<string> {
+  const expectedPath = join(packageDir, binName);
+  if (await isExecutable(expectedPath)) return expectedPath;
+
+  if (extractedPath && (await isExecutable(extractedPath))) {
+    await copyFile(extractedPath, expectedPath);
+    await chmod(expectedPath, 0o755).catch(() => undefined);
+    return expectedPath;
+  }
+
+  throw new MissingBinaryError(serverId, expectedPath);
+}
+
+async function resolveExecutable(command: string, env: Record<string, string>, serverId: string): Promise<string> {
+  if (command.includes("/") || command.includes("\\") || isAbsolute(command)) {
+    const absolute = isAbsolute(command) ? command : resolve(command);
+    await assertExecutable(absolute, command, serverId);
+    return absolute;
+  }
+
+  const pathEntries = (env.PATH ?? "").split(process.platform === "win32" ? ";" : ":").filter(Boolean);
+  const extensions = process.platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";") : [""];
+
+  for (const directory of pathEntries) {
+    for (const extension of extensions) {
+      const candidate = join(directory, `${command}${extension}`);
+      if (await isExecutable(candidate)) {
+        return candidate;
+      }
+    }
+  }
+
+  throw new MissingBinaryError(serverId, command);
+}
+
+async function assertExecutable(path: string, originalCommand: string, serverId: string): Promise<void> {
+  if (!(await isExecutable(path))) {
+    throw new MissingBinaryError(serverId, originalCommand);
+  }
+}
+
+async function isExecutable(path: string): Promise<boolean> {
+  try {
+    await access(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function resolveGithubAssetName(install: GithubInstallSpec, requestedVersion: string | undefined): string {
+  if (!install.asset) {
+    return install.bin;
+  }
+
+  const version = requestedVersion ?? install.version;
+  if (install.asset.includes("{version}") && !version) {
+    throw new ConfigError(`GitHub installer for ${install.repo} requires a version because asset uses {version}.`);
+  }
+
+  return install.asset.replaceAll("{version}", version ?? "latest").replaceAll("{platform}", getGithubPlatformToken());
+}
+
+export function buildGithubAssetUrl(
+  install: GithubInstallSpec,
+  assetName: string,
+  version: string | undefined,
+): string {
+  if (install.downloadUrl) {
+    const resolvedVersion = version ?? "latest";
+    return install.downloadUrl.replaceAll("{version}", resolvedVersion).replaceAll("{asset}", assetName);
+  }
+
+  const releasePath = version ? `download/${version}` : "latest/download";
+  return `https://github.com/${install.repo}/releases/${releasePath}/${assetName}`;
+}
+
+async function extractGithubAsset(
+  runner: CommandRunner,
+  archivePath: string,
+  packageDir: string,
+  stripComponents: number,
+): Promise<string | undefined> {
+  if (archivePath.endsWith(".tar.gz") || archivePath.endsWith(".tgz")) {
+    const args = ["-xzf", archivePath, "-C", packageDir];
+    if (stripComponents > 0) args.push("--strip-components", String(stripComponents));
+    await runChecked(runner, { command: "tar", args });
+    return undefined;
+  }
+
+  if (archivePath.endsWith(".zip")) {
+    await runChecked(runner, { command: "unzip", args: ["-q", archivePath, "-d", packageDir] });
+    return undefined;
+  }
+
+  const destination = join(packageDir, basename(archivePath));
+  await copyFile(archivePath, destination);
+  await chmod(destination, 0o755).catch(() => undefined);
+  return destination;
+}
+
+export function getGithubPlatformToken(platform: string = process.platform, arch: string = process.arch): string {
+  if (platform === "linux") {
+    if (arch === "x64") return "x86_64-unknown-linux-gnu";
+    if (arch === "arm64") return "aarch64-unknown-linux-gnu";
+    if (arch === "arm") return "arm-unknown-linux-gnueabihf";
+  }
+
+  if (platform === "darwin") {
+    if (arch === "x64") return "x86_64-apple-darwin";
+    if (arch === "arm64") return "aarch64-apple-darwin";
+  }
+
+  if (platform === "win32") {
+    if (arch === "x64") return "x86_64-pc-windows-msvc";
+    if (arch === "arm64") return "aarch64-pc-windows-msvc";
+    if (arch === "ia32") return "i686-pc-windows-msvc";
+  }
+
+  return `${platform}-${arch}`;
+}
+
+async function defaultDownloadFile(url: string, destinationPath: string): Promise<void> {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new ConfigError(`Failed to download ${url}: HTTP ${response.status}`);
+  }
+
+  const buffer = Buffer.from(await response.arrayBuffer());
+  await writeFile(destinationPath, buffer);
+}
+
+export async function defaultCommandRunner(invocation: CommandInvocation): Promise<CommandResult> {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(invocation.command, invocation.args, {
+      cwd: invocation.cwd,
+      env: invocation.env,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk: string) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk: string) => {
+      stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      resolvePromise({ code: code ?? 1, stdout, stderr });
+    });
+  });
+}
+
+function formatInstallLog(lines: string[]): string {
+  return `${lines.join("\n")}\n`;
+}
+
+function tail(value: string): string {
+  const lines = value.trim().split(/\r?\n/u);
+  return lines.slice(-10).join("\n");
+}

package/src/install/lockfile.ts

@@ -0,0 +1,159 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import {
+  getBinDir,
+  getCacheDir,
+  getLockfilePath,
+  getLogsDir,
+  getManagedLspRoot,
+  getPackagesDir,
+  getProcessRegistryDir,
+  getRegistryDir,
+  getWorkspacesDir,
+} from "../config/paths.js";
+import { InstalledServerMetadataSchema } from "../registry/schema.js";
+import type { InstalledServerMetadata, InstallerType } from "../registry/schema.js";
+import { isNodeError, isPlainObject, messageFromError } from "../util/helpers.js";
+import { Value } from "typebox/value";
+import { ConfigError } from "../util/errors.js";
+
+export interface LspLockfile {
+  servers: Record<string, InstalledServerMetadata>;
+}
+
+export interface LockfileOptions {
+  lockfilePath?: string;
+}
+
+export interface CreateInstalledServerMetadataInput {
+  installer: InstallerType;
+  requestedVersion?: string;
+  packages?: Record<string, string>;
+  resolvedCommand: string[];
+  packageDir?: string;
+  binDir?: string;
+  installedAt?: Date;
+}
+
+export async function ensureManagedLspRoot(): Promise<void> {
+  await Promise.all([
+    mkdir(getManagedLspRoot(), { recursive: true }),
+    mkdir(getRegistryDir(), { recursive: true }),
+    mkdir(getPackagesDir(), { recursive: true }),
+    mkdir(getBinDir(), { recursive: true }),
+    mkdir(getCacheDir(), { recursive: true }),
+    mkdir(getLogsDir(), { recursive: true }),
+    mkdir(getWorkspacesDir(), { recursive: true }),
+    mkdir(getProcessRegistryDir(), { recursive: true }),
+  ]);
+}
+
+export async function readLockfile(options: LockfileOptions = {}): Promise<LspLockfile> {
+  const lockfilePath = options.lockfilePath ?? getLockfilePath();
+  const paths = options.lockfilePath ? [lockfilePath] : [lockfilePath, getLegacyLockfilePath(lockfilePath)];
+
+  for (const path of paths) {
+    try {
+      return await readLockfileAt(path);
+    } catch (error) {
+      if (isNodeError(error) && error.code === "ENOENT") continue;
+      throw error;
+    }
+  }
+
+  return { servers: {} };
+}
+
+async function readLockfileAt(lockfilePath: string): Promise<LspLockfile> {
+  const raw = await readFile(lockfilePath, "utf8");
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new ConfigError(`Invalid LSP lockfile at ${lockfilePath}: ${messageFromError(error)}`);
+  }
+
+  if (!isLockfile(parsed)) {
+    throw new ConfigError(
+      `Invalid LSP lockfile at ${lockfilePath}: expected { servers: { ... } } with valid server metadata.`,
+    );
+  }
+
+  return { servers: parsed.servers };
+}
+
+function getLegacyLockfilePath(lockfilePath: string): string {
+  return join(dirname(lockfilePath), "lock.json");
+}
+
+export async function writeLockfile(lockfile: LspLockfile, options: LockfileOptions = {}): Promise<void> {
+  const lockfilePath = options.lockfilePath ?? getLockfilePath();
+  await ensureManagedLspRoot();
+  await mkdir(dirname(lockfilePath), { recursive: true });
+
+  const tempPath = `${lockfilePath}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(tempPath, `${JSON.stringify(normalizeLockfile(lockfile), null, 2)}\n`, "utf8");
+  await rename(tempPath, lockfilePath);
+}
+
+export async function writeServerLockfileEntry(
+  serverId: string,
+  metadata: InstalledServerMetadata,
+  options: LockfileOptions = {},
+): Promise<LspLockfile> {
+  const lockfile = await readLockfile(options);
+  lockfile.servers[serverId] = metadata;
+  await writeLockfile(lockfile, options);
+  return lockfile;
+}
+
+export async function removeServerLockfileEntry(serverId: string, options: LockfileOptions = {}): Promise<LspLockfile> {
+  const lockfile = await readLockfile(options);
+  delete lockfile.servers[serverId];
+  await writeLockfile(lockfile, options);
+  return lockfile;
+}
+
+export function createInstalledServerMetadata(input: CreateInstalledServerMetadataInput): InstalledServerMetadata {
+  const metadata: InstalledServerMetadata = {
+    installer: input.installer,
+    resolvedCommand: input.resolvedCommand,
+    installedAt: (input.installedAt ?? new Date()).toISOString(),
+  };
+
+  if (input.requestedVersion !== undefined) {
+    metadata.requestedVersion = input.requestedVersion;
+  }
+
+  if (input.packages !== undefined) {
+    metadata.packages = input.packages;
+  }
+
+  if (input.packageDir !== undefined) {
+    metadata.packageDir = input.packageDir;
+  }
+
+  if (input.binDir !== undefined) {
+    metadata.binDir = input.binDir;
+  }
+
+  return metadata;
+}
+
+function normalizeLockfile(lockfile: LspLockfile): LspLockfile {
+  return {
+    servers: Object.fromEntries(Object.entries(lockfile.servers).sort(([left], [right]) => left.localeCompare(right))),
+  };
+}
+
+function isLockfile(value: unknown): value is LspLockfile {
+  if (!isPlainObject(value) || !isPlainObject(value.servers)) {
+    return false;
+  }
+
+  return Object.values(value.servers).every(isInstalledServerMetadata);
+}
+
+function isInstalledServerMetadata(value: unknown): value is InstalledServerMetadata {
+  return Value.Check(InstalledServerMetadataSchema, value);
+}