pi-lsp-adapter 0.1.0

package/src/lsp/runtimeManager.ts

@@ -0,0 +1,552 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute, relative, resolve } from "node:path";
+import { delay } from "../util/helpers.js";
+import type {
+  Definition,
+  DocumentSymbol,
+  Hover,
+  Location,
+  LocationLink,
+  SymbolInformation,
+  WorkspaceSymbol,
+} from "vscode-languageserver-protocol";
+import { detectFiletype } from "../detect/filetypes.js";
+import { detectRoot } from "../detect/root.js";
+import type { LoadLspConfigResult } from "../config/loadConfig.js";
+import type { LspInstallManager } from "../install/manager.js";
+import { readLockfile, type LockfileOptions } from "../install/lockfile.js";
+import type { InstalledServerMetadata, ServerDefinition } from "../registry/schema.js";
+import { resolveServerConfig } from "../resolve/resolveServer.js";
+import type { LspProcessRegistry } from "./processRegistry.js";
+import { LspClient, type LspConnectionFactory, type LspDiagnosticsResult, type LspServerSpawner } from "./client.js";
+
+export interface LspRuntimeManagerOptions {
+  cwd: string;
+  ownerId: string;
+  config: LoadLspConfigResult;
+  installManager: LspInstallManager;
+  processRegistry: LspProcessRegistry;
+  spawner?: LspServerSpawner;
+  connectionFactory?: LspConnectionFactory;
+  lockfileOptions?: LockfileOptions;
+  requestTimeoutMs?: number;
+  diagnosticsWaitMs?: number;
+  shutdownGraceMs?: number;
+}
+
+export type LspStartStatus = "started" | "already-running" | "missing" | "declined" | "error";
+
+export interface LspStartResult {
+  serverId: string;
+  rootDir: string;
+  status: LspStartStatus;
+  message: string;
+  installedNow?: boolean;
+}
+
+export interface LspRuntimeFileResult<T> {
+  serverId: string;
+  rootDir: string;
+  filePath: string;
+  uri: string;
+  result: T;
+}
+
+export interface LspWorkspaceSymbolsResult {
+  serverId: string;
+  rootDir: string;
+  result: SymbolInformation[] | WorkspaceSymbol[] | null;
+}
+
+interface SelectedServer {
+  server: ServerDefinition;
+  rootDir: string;
+  rootMarker?: string;
+  filetype: string;
+  filePath: string;
+  text: string;
+}
+
+interface ClientTarget {
+  client: LspClient;
+  serverId: string;
+  rootDir: string;
+  started: boolean;
+}
+
+interface ClientShutdownResult {
+  client: LspClient;
+  stopped: boolean;
+}
+
+interface ClientStartOptions {
+  allowPromptInstall: boolean;
+  allowAutoInstall?: boolean;
+}
+
+interface EnsureClientInput {
+  server: ServerDefinition;
+  rootDir: string;
+  rootMarker?: string;
+  allowPromptInstall: boolean;
+  allowAutoInstall?: boolean;
+}
+
+interface StartClientInput extends EnsureClientInput {
+  key: string;
+}
+
+export class LspRuntimeError extends Error {
+  constructor(
+    message: string,
+    readonly code:
+      | "no-filetype"
+      | "no-server"
+      | "not-installed"
+      | "declined"
+      | "start-failed"
+      | "outside-workspace"
+      | "invalid-position",
+  ) {
+    super(message);
+    this.name = "LspRuntimeError";
+  }
+}
+
+export class LspRuntimeManager {
+  private readonly cwd: string;
+  private readonly ownerId: string;
+  private readonly config: LoadLspConfigResult;
+  private readonly installManager: LspInstallManager;
+  private readonly processRegistry: LspProcessRegistry;
+  private readonly spawner?: LspServerSpawner;
+  private readonly connectionFactory?: LspConnectionFactory;
+  private readonly lockfileOptions: LockfileOptions;
+  private readonly requestTimeoutMs: number;
+  private readonly diagnosticsWaitMs: number;
+  private readonly shutdownGraceMs: number;
+  private readonly clients = new Map<string, LspClient>();
+  private readonly starting = new Map<string, Promise<ClientTarget>>();
+  private readonly filetypeCache = new Map<string, string>();
+
+  constructor(options: LspRuntimeManagerOptions) {
+    this.cwd = options.cwd;
+    this.ownerId = options.ownerId;
+    this.config = options.config;
+    this.installManager = options.installManager;
+    this.processRegistry = options.processRegistry;
+    this.spawner = options.spawner;
+    this.connectionFactory = options.connectionFactory;
+    this.lockfileOptions = options.lockfileOptions ?? {};
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 10_000;
+    this.diagnosticsWaitMs = options.diagnosticsWaitMs ?? 350;
+    this.shutdownGraceMs = options.shutdownGraceMs ?? 1_000;
+  }
+
+  async startServer(
+    serverId?: string,
+    options: ClientStartOptions = { allowPromptInstall: false },
+  ): Promise<LspStartResult[]> {
+    const targets = serverId ? [serverId] : await this.installedServerIds();
+    if (targets.length === 0) return [];
+
+    const results: LspStartResult[] = [];
+    for (const targetId of targets) {
+      results.push(await this.startServerAtRoot(targetId, this.cwd, options));
+    }
+    return results;
+  }
+
+  async restartServer(
+    serverId?: string,
+    options: ClientStartOptions = { allowPromptInstall: false },
+  ): Promise<LspStartResult[]> {
+    const targetIds = new Set(serverId ? [serverId] : [...this.clients.values()].map((client) => client.serverId));
+    if (!serverId && targetIds.size === 0) {
+      return this.startServer(undefined, options);
+    }
+
+    const stopped = await this.shutdownClients((client) => targetIds.has(client.serverId));
+    const failed = stopped.filter((entry) => !entry.stopped);
+    if (failed.length > 0) {
+      return failed.map(({ client }) => ({
+        serverId: client.serverId,
+        rootDir: client.rootDir,
+        status: "error",
+        message: `Could not restart ${client.serverId} for ${client.rootDir}; old process did not exit.`,
+      }));
+    }
+
+    return this.startServer(serverId, options);
+  }
+
+  async shutdown(): Promise<void> {
+    this.filetypeCache.clear();
+    await this.shutdownClients(() => true);
+  }
+
+  async stopServer(serverId?: string): Promise<number> {
+    const stopped = await this.shutdownClients((client) => !serverId || client.serverId === serverId);
+    return stopped.filter((entry) => entry.stopped).length;
+  }
+
+  async warmupFile(filePath: string): Promise<boolean> {
+    try {
+      const selected = await this.selectServerForFile(filePath);
+      const target = await this.ensureClient({
+        server: selected.server,
+        rootDir: selected.rootDir,
+        rootMarker: selected.rootMarker,
+        allowPromptInstall: false,
+        allowAutoInstall: false,
+      });
+      await target.client.syncFile(selected.filePath, selected.filetype, selected.text);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async diagnostics(filePath: string): Promise<LspDiagnosticsResult> {
+    const target = await this.prepareFileTarget(filePath);
+    await delay(this.diagnosticsWaitMs);
+    return {
+      serverId: target.client.serverId,
+      rootDir: target.client.rootDir,
+      filePath: target.filePath,
+      uri: target.uri,
+      diagnostics: target.client.getDiagnostics(target.uri),
+    };
+  }
+
+  async hover(filePath: string, line: number, character: number): Promise<LspRuntimeFileResult<Hover | null>> {
+    const target = await this.prepareFilePositionTarget(filePath, line, character);
+    return {
+      serverId: target.client.serverId,
+      rootDir: target.client.rootDir,
+      filePath: target.filePath,
+      uri: target.uri,
+      result: await target.client.hover(target.uri, line, character),
+    };
+  }
+
+  async definition(
+    filePath: string,
+    line: number,
+    character: number,
+  ): Promise<LspRuntimeFileResult<Definition | LocationLink[] | null>> {
+    const target = await this.prepareFilePositionTarget(filePath, line, character);
+    return {
+      serverId: target.client.serverId,
+      rootDir: target.client.rootDir,
+      filePath: target.filePath,
+      uri: target.uri,
+      result: await target.client.definition(target.uri, line, character),
+    };
+  }
+
+  async references(
+    filePath: string,
+    line: number,
+    character: number,
+    includeDeclaration = false,
+  ): Promise<LspRuntimeFileResult<Location[] | null>> {
+    const target = await this.prepareFilePositionTarget(filePath, line, character);
+    return {
+      serverId: target.client.serverId,
+      rootDir: target.client.rootDir,
+      filePath: target.filePath,
+      uri: target.uri,
+      result: await target.client.references(target.uri, line, character, includeDeclaration),
+    };
+  }
+
+  async documentSymbols(
+    filePath: string,
+  ): Promise<LspRuntimeFileResult<DocumentSymbol[] | SymbolInformation[] | null>> {
+    const target = await this.prepareFileTarget(filePath);
+    return {
+      serverId: target.client.serverId,
+      rootDir: target.client.rootDir,
+      filePath: target.filePath,
+      uri: target.uri,
+      result: await target.client.documentSymbols(target.uri),
+    };
+  }
+
+  async workspaceSymbols(
+    query: string,
+    serverId?: string,
+    options: ClientStartOptions = { allowPromptInstall: false },
+  ): Promise<LspWorkspaceSymbolsResult[]> {
+    const clients = serverId
+      ? [
+          await this.ensureClient({
+            server: this.getServer(serverId),
+            rootDir: this.cwd,
+            allowPromptInstall: options.allowPromptInstall,
+          }),
+        ]
+      : this.workspaceSymbolClients();
+    const results: LspWorkspaceSymbolsResult[] = [];
+    for (const target of clients) {
+      results.push({
+        serverId: target.client.serverId,
+        rootDir: target.client.rootDir,
+        result: await target.client.workspaceSymbols(query),
+      });
+    }
+    return results;
+  }
+
+  activeClients(): Array<{ id: string; serverId: string; rootDir: string }> {
+    const active: Array<{ id: string; serverId: string; rootDir: string }> = [];
+    for (const client of this.clients.values()) {
+      if (!client.isExited) active.push({ id: client.id, serverId: client.serverId, rootDir: client.rootDir });
+    }
+    return active;
+  }
+
+  private workspaceSymbolClients(): ClientTarget[] {
+    const active: ClientTarget[] = [];
+    for (const client of this.clients.values()) {
+      if (!client.isExited) active.push({ client, serverId: client.serverId, rootDir: client.rootDir, started: false });
+    }
+    return active;
+  }
+
+  private async prepareFileTarget(filePath: string): Promise<SelectedServer & { client: LspClient; uri: string }> {
+    const selected = await this.selectServerForFile(filePath);
+    return this.attachClient(selected);
+  }
+
+  private async prepareFilePositionTarget(
+    filePath: string,
+    line: number,
+    character: number,
+  ): Promise<SelectedServer & { client: LspClient; uri: string }> {
+    const selected = await this.selectServerForFile(filePath);
+    validatePosition(selected, line, character);
+    return this.attachClient(selected);
+  }
+
+  private async attachClient(selected: SelectedServer): Promise<SelectedServer & { client: LspClient; uri: string }> {
+    const target = await this.ensureClient({
+      server: selected.server,
+      rootDir: selected.rootDir,
+      rootMarker: selected.rootMarker,
+      allowPromptInstall: false,
+    });
+    const uri = await target.client.syncFile(selected.filePath, selected.filetype, selected.text);
+    return { ...selected, client: target.client, uri };
+  }
+
+  private async selectServerForFile(filePath: string): Promise<SelectedServer> {
+    const resolvedPath = this.resolvePath(filePath);
+    const text = await readFile(resolvedPath, "utf8");
+    const cached = this.filetypeCache.get(resolvedPath);
+    const filetype = cached ?? detectFiletype({ path: resolvedPath, content: text });
+    if (cached === undefined) {
+      if (filetype) this.filetypeCache.set(resolvedPath, filetype);
+    }
+    if (!filetype) {
+      throw new LspRuntimeError(`No LSP filetype detected for ${resolvedPath}.`, "no-filetype");
+    }
+
+    const server = Object.values(this.config.catalog.servers).find((entry) => entry.filetypes.includes(filetype));
+    if (!server) {
+      throw new LspRuntimeError(
+        `No configured LSP server handles filetype ${filetype} for ${resolvedPath}.`,
+        "no-server",
+      );
+    }
+
+    const root = await detectRoot(resolvedPath, server.rootMarkers);
+    const rootDir = root && isPathInside(this.cwd, root.rootDir) ? root.rootDir : this.cwd;
+    return {
+      server,
+      rootDir,
+      rootMarker: rootDir === root?.rootDir ? root.marker : undefined,
+      filetype,
+      filePath: resolvedPath,
+      text,
+    };
+  }
+
+  private async startServerAtRoot(
+    serverId: string,
+    rootDir: string,
+    options: ClientStartOptions,
+  ): Promise<LspStartResult> {
+    try {
+      const target = await this.ensureClient({
+        server: this.getServer(serverId),
+        rootDir,
+        allowPromptInstall: options.allowPromptInstall,
+      });
+      return {
+        serverId,
+        rootDir: target.rootDir,
+        status: target.started ? "started" : "already-running",
+        message: target.started
+          ? `Started ${serverId} for ${target.rootDir}.`
+          : `${serverId} is already running for ${target.rootDir}.`,
+      };
+    } catch (error) {
+      if (error instanceof LspRuntimeError && (error.code === "not-installed" || error.code === "declined")) {
+        return {
+          serverId,
+          rootDir,
+          status: error.code === "not-installed" ? "missing" : "declined",
+          message: error.message,
+        };
+      }
+      return { serverId, rootDir, status: "error", message: error instanceof Error ? error.message : String(error) };
+    }
+  }
+
+  private getServer(serverId: string): ServerDefinition {
+    const server = this.config.catalog.servers[serverId];
+    if (!server) throw new LspRuntimeError(`Unknown LSP server: ${serverId}.`, "no-server");
+    return server;
+  }
+
+  private async ensureClient(input: EnsureClientInput): Promise<ClientTarget> {
+    const server = input.server;
+    const rootDir = resolve(input.rootDir);
+    const key = clientKey(server.id, rootDir);
+    const existing = this.clients.get(key);
+    if (existing && !existing.isExited) {
+      return { client: existing, serverId: server.id, rootDir, started: false };
+    }
+
+    const inflight = this.starting.get(key);
+    if (inflight) return inflight;
+
+    const start = this.startClient({ ...input, rootDir, key });
+    this.starting.set(key, start);
+    try {
+      return await start;
+    } finally {
+      this.starting.delete(key);
+    }
+  }
+
+  private async startClient(input: StartClientInput): Promise<ClientTarget> {
+    const install = await this.ensureInstalled(input.server.id, {
+      allowPromptInstall: input.allowPromptInstall,
+      allowAutoInstall: input.allowAutoInstall,
+    });
+    const resolved = await resolveServerConfig({
+      server: input.server,
+      rootDir: input.rootDir,
+      rootMarker: input.rootMarker,
+      install,
+    });
+    let client: LspClient | undefined;
+    try {
+      client = new LspClient({
+        id: input.key,
+        ownerId: this.ownerId,
+        config: resolved,
+        processRegistry: this.processRegistry,
+        spawner: this.spawner,
+        connectionFactory: this.connectionFactory,
+        requestTimeoutMs: this.requestTimeoutMs,
+        shutdownGraceMs: this.shutdownGraceMs,
+      });
+      await client.start();
+      this.clients.set(input.key, client);
+      return { client, serverId: input.server.id, rootDir: input.rootDir, started: true };
+    } catch (error) {
+      await client?.shutdown().catch(() => false);
+      throw new LspRuntimeError(
+        `Failed to start ${input.server.id}: ${error instanceof Error ? error.message : String(error)}`,
+        "start-failed",
+      );
+    }
+  }
+
+  private async ensureInstalled(serverId: string, options: ClientStartOptions): Promise<InstalledServerMetadata> {
+    const lockfile = await readLockfile(this.lockfileOptions);
+    const existing = lockfile.servers[serverId];
+    if (existing) return existing;
+
+    if (!options.allowPromptInstall && (!(options.allowAutoInstall ?? true) || this.config.installMode !== "auto")) {
+      throw new LspRuntimeError(
+        `${serverId} is not installed. Run /lsp install ${serverId} to install it explicitly.`,
+        "not-installed",
+      );
+    }
+
+    const result = await this.installManager.ensureInstalled(serverId);
+    if (result.status === "installed") return result.metadata;
+    throw new LspRuntimeError(result.message, result.status === "declined" ? "declined" : "not-installed");
+  }
+
+  private async installedServerIds(): Promise<string[]> {
+    const lockfile = await readLockfile(this.lockfileOptions);
+    return Object.keys(lockfile.servers).filter((serverId) => this.config.catalog.servers[serverId] !== undefined);
+  }
+
+  private async shutdownClients(predicate: (client: LspClient) => boolean): Promise<ClientShutdownResult[]> {
+    const entries = [...this.clients.entries()].filter(([_key, client]) => predicate(client));
+    const stopped = await Promise.all(
+      entries.map(async ([key, client]) => {
+        const didStop = await client.shutdown();
+        if (didStop || client.isExited) this.clients.delete(key);
+        return { client, stopped: didStop || client.isExited };
+      }),
+    );
+    return stopped;
+  }
+
+  private resolvePath(filePath: string): string {
+    const resolvedPath = isAbsolute(filePath) ? resolve(filePath) : resolve(this.cwd, filePath);
+    if (!isPathInside(this.cwd, resolvedPath)) {
+      throw new LspRuntimeError(
+        `Refusing to start LSP for ${resolvedPath}; target is outside workspace ${this.cwd}.`,
+        "outside-workspace",
+      );
+    }
+    return resolvedPath;
+  }
+}
+
+function clientKey(serverId: string, rootDir: string): string {
+  return `${serverId}:${rootDir}`;
+}
+
+function isPathInside(rootDir: string, targetPath: string): boolean {
+  const relativePath = relative(resolve(rootDir), resolve(targetPath));
+  return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+}
+
+function validatePosition(selected: SelectedServer, line: number, character: number): void {
+  const lines = splitLines(selected.text);
+  if (!Number.isInteger(line) || !Number.isInteger(character) || line < 0 || character < 0) {
+    throw new LspRuntimeError(
+      `Invalid LSP position for ${selected.filePath}. Use a valid 1-based line/column from the file and place the column on an identifier token.`,
+      "invalid-position",
+    );
+  }
+
+  if (line >= lines.length) {
+    throw new LspRuntimeError(
+      `Position is outside ${selected.filePath}: line ${line + 1} was requested, but the file has ${lines.length} line(s). Use a valid 1-based line/column from the file and place the column on an identifier token.`,
+      "invalid-position",
+    );
+  }
+
+  const maxCharacter = lines[line]?.length ?? 0;
+  if (character > maxCharacter) {
+    throw new LspRuntimeError(
+      `Position is outside ${selected.filePath}: column ${character + 1} was requested on line ${line + 1}, but the maximum column is ${maxCharacter + 1}. Place the column on the identifier token you want to inspect.`,
+      "invalid-position",
+    );
+  }
+}
+
+function splitLines(text: string): string[] {
+  return text.split(/\r\n|\r|\n/u);
+}