pi-lsp-adapter 0.1.0

package/src/commands/registerCommands.ts

@@ -0,0 +1,228 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { readLockfile } from "../install/lockfile.js";
+import { parseServerVersionSpec } from "../install/version.js";
+import type { LspExtensionState } from "../state.js";
+import { setLspStatusLine } from "../statusLine.js";
+import { LspPanel, type LspPanelAction } from "../ui/lspPanel.js";
+import { formatLspDoctor, formatLspStatus, type LspStatusSnapshot } from "./status.js";
+
+export type GetLspState = () => LspExtensionState | null;
+
+export function registerLspCommand(pi: ExtensionAPI, getState: GetLspState): void {
+  pi.registerCommand("lsp", {
+    description: "Show and manage LSP server status",
+    handler: async (args, ctx) => {
+      const state = getState();
+      if (!state) {
+        notify(ctx, "LSP extension is not initialized.", "error");
+        return;
+      }
+
+      const parts = args.trim().split(/\s+/u).filter(Boolean);
+      const subcommand = parts[0] ?? "";
+
+      try {
+        switch (subcommand) {
+          case "":
+          case "status":
+            await showStatusOrPanel(state, ctx, subcommand === "status");
+            return;
+          case "doctor":
+            await showDoctor(state, ctx, parts[1]);
+            return;
+          case "install":
+            await installServer(state, ctx, parts[1]);
+            return;
+          case "update":
+            await updateServer(state, ctx, parts[1]);
+            return;
+          case "uninstall":
+            await uninstallServer(state, ctx, parts[1]);
+            return;
+          case "stop":
+            await stopProcesses(state, ctx, parts[1]);
+            return;
+          case "start":
+            await startServers(state, ctx, parts[1]);
+            return;
+          case "restart":
+            await restartServers(state, ctx, parts[1]);
+            return;
+          default:
+            notify(ctx, `Unknown /lsp subcommand: ${subcommand}`, "error");
+        }
+      } catch (error) {
+        notify(ctx, error instanceof Error ? error.message : String(error), "error");
+      }
+    },
+  });
+}
+
+async function showStatusOrPanel(
+  state: LspExtensionState,
+  ctx: ExtensionCommandContext,
+  forceText: boolean,
+): Promise<void> {
+  const snapshot = await buildSnapshot(state);
+  if (!ctx.hasUI || forceText) {
+    notify(ctx, formatLspStatus(snapshot), "info");
+    return;
+  }
+
+  const action = await ctx.ui.custom<LspPanelAction>(
+    (tui, theme, _keybindings, done) => {
+      const panel = new LspPanel(snapshot, theme, done);
+      return {
+        render: (width: number) => panel.render(width),
+        invalidate: () => panel.invalidate(),
+        handleInput: (data: string) => {
+          panel.handleInput(data);
+          tui.requestRender();
+        },
+      };
+    },
+    { overlay: true, overlayOptions: { anchor: "center", width: 92 } },
+  );
+
+  await handlePanelAction(action, state, ctx);
+}
+
+async function handlePanelAction(
+  action: LspPanelAction | undefined,
+  state: LspExtensionState,
+  ctx: ExtensionCommandContext,
+): Promise<void> {
+  if (!action || action.type === "close") return;
+  switch (action.type) {
+    case "doctor":
+      await showDoctor(state, ctx, action.serverId);
+      return;
+    case "install":
+      await installServer(state, ctx, action.serverId);
+      return;
+    case "update":
+      await updateServer(state, ctx, action.serverId);
+      return;
+    case "uninstall":
+      await uninstallServer(state, ctx, action.serverId);
+      return;
+    case "stop":
+      await stopProcesses(state, ctx, action.serverId);
+      return;
+    case "refresh":
+      await showStatusOrPanel(state, ctx, false);
+  }
+}
+
+async function showDoctor(state: LspExtensionState, ctx: ExtensionCommandContext, serverId?: string): Promise<void> {
+  notify(ctx, formatLspDoctor(await buildSnapshot(state), serverId), "info");
+}
+
+async function installServer(
+  state: LspExtensionState,
+  ctx: ExtensionCommandContext,
+  spec: string | undefined,
+): Promise<void> {
+  if (!spec) {
+    notify(ctx, "Usage: /lsp install <serverId[@version]>", "error");
+    return;
+  }
+  const { serverId, version } = parseServerVersionSpec(spec);
+  const result = await state.installManager.installServer(serverId, version);
+  notify(ctx, `Installed ${result.serverId}: ${result.metadata.resolvedCommand.join(" ")}`, "info");
+}
+
+async function updateServer(
+  state: LspExtensionState,
+  ctx: ExtensionCommandContext,
+  spec: string | undefined,
+): Promise<void> {
+  if (!spec) {
+    notify(ctx, "Usage: /lsp update <serverId[@version]> or /lsp update --all", "error");
+    return;
+  }
+
+  if (spec === "--all") {
+    for (const serverId of Object.keys(state.config.catalog.servers)) {
+      await state.installManager.updateServer(serverId);
+    }
+    notify(ctx, "Updated all configured LSP servers.", "info");
+    return;
+  }
+
+  const { serverId, version } = parseServerVersionSpec(spec);
+  const result = await state.installManager.updateServer(serverId, version);
+  notify(ctx, `Updated ${result.serverId}: ${result.metadata.resolvedCommand.join(" ")}`, "info");
+}
+
+async function uninstallServer(
+  state: LspExtensionState,
+  ctx: ExtensionCommandContext,
+  serverId: string | undefined,
+): Promise<void> {
+  if (!serverId) {
+    notify(ctx, "Usage: /lsp uninstall <serverId>", "error");
+    return;
+  }
+
+  const runtimeStopped = await state.runtimeManager.stopServer(serverId);
+  const stopped = runtimeStopped + (await terminateMatchingProcesses(state, serverId));
+  const result = await state.installManager.uninstallServer(serverId);
+  setLspStatusLine(ctx, state);
+  notify(
+    ctx,
+    `${result.removed ? "Uninstalled" : "No install found for"} ${serverId}; stopped ${stopped} process(es).`,
+    "info",
+  );
+}
+
+async function startServers(state: LspExtensionState, ctx: ExtensionCommandContext, serverId?: string): Promise<void> {
+  const results = await state.runtimeManager.startServer(serverId, { allowPromptInstall: true });
+  setLspStatusLine(ctx, state);
+  notify(ctx, formatStartResults("start", results), hasStartErrors(results) ? "warning" : "info");
+}
+
+async function restartServers(
+  state: LspExtensionState,
+  ctx: ExtensionCommandContext,
+  serverId?: string,
+): Promise<void> {
+  const results = await state.runtimeManager.restartServer(serverId, { allowPromptInstall: true });
+  setLspStatusLine(ctx, state);
+  notify(ctx, formatStartResults("restart", results), hasStartErrors(results) ? "warning" : "info");
+}
+
+async function stopProcesses(state: LspExtensionState, ctx: ExtensionCommandContext, serverId?: string): Promise<void> {
+  const runtimeStopped = await state.runtimeManager.stopServer(serverId);
+  const stopped = runtimeStopped + (await terminateMatchingProcesses(state, serverId));
+  setLspStatusLine(ctx, state);
+  notify(ctx, `Stopped ${stopped} tracked LSP process(es)${serverId ? ` for ${serverId}` : ""}.`, "info");
+}
+
+async function terminateMatchingProcesses(state: LspExtensionState, serverId?: string): Promise<number> {
+  const result = await state.processRegistry.terminateProcesses((entry) => !serverId || entry.serverId === serverId);
+  return result.terminated.length + result.removed.length;
+}
+
+async function buildSnapshot(state: LspExtensionState): Promise<LspStatusSnapshot> {
+  return {
+    config: state.config,
+    lockfile: await readLockfile(),
+    processes: await state.processRegistry.list(),
+  };
+}
+
+function formatStartResults(action: "start" | "restart", results: Array<{ status: string; message: string }>): string {
+  if (results.length === 0) return `No installed LSP servers to ${action}. Run /lsp install <serverId> first.`;
+  return results.map((result) => result.message).join("\n");
+}
+
+function hasStartErrors(results: Array<{ status: string }>): boolean {
+  return results.some(
+    (result) => result.status === "missing" || result.status === "declined" || result.status === "error",
+  );
+}
+
+function notify(ctx: ExtensionCommandContext, message: string, level: "info" | "warning" | "error"): void {
+  if (ctx.hasUI) ctx.ui.notify(message, level);
+}

package/src/commands/status.ts

@@ -0,0 +1,79 @@
+import type { LoadLspConfigResult } from "../config/loadConfig.js";
+import type { LspLockfile } from "../install/lockfile.js";
+import type { LspProcessEntry } from "../lsp/processRegistry.js";
+import type { ServerDefinition } from "../registry/schema.js";
+
+export interface LspStatusSnapshot {
+  config: LoadLspConfigResult;
+  lockfile: LspLockfile;
+  processes: LspProcessEntry[];
+}
+
+export function formatLspStatus(snapshot: LspStatusSnapshot): string {
+  const lines = ["LSP status", ""];
+  lines.push(`installMode: ${snapshot.config.installMode}`);
+  lines.push(`warmup: ${snapshot.config.warmup ? "enabled" : "disabled"}`);
+  lines.push(`servers: ${Object.keys(snapshot.config.catalog.servers).length}`);
+  lines.push(`tracked processes: ${snapshot.processes.length}`);
+
+  if (snapshot.config.warnings.length > 0) {
+    lines.push("", "warnings:");
+    for (const warning of snapshot.config.warnings) lines.push(`- ${warning}`);
+  }
+
+  lines.push("", "servers:");
+  for (const server of Object.values(snapshot.config.catalog.servers)) {
+    const installed = snapshot.lockfile.servers[server.id] ? "installed" : "missing";
+    const processCount = snapshot.processes.filter((process) => process.serverId === server.id).length;
+    lines.push(`- ${server.id}: ${installed}, ${processCount} process${processCount === 1 ? "" : "es"}`);
+  }
+
+  return lines.join("\n");
+}
+
+export function formatLspDoctor(snapshot: LspStatusSnapshot, serverId?: string): string {
+  if (serverId) {
+    const server = snapshot.config.catalog.servers[serverId];
+    if (!server) return `Unknown LSP server: ${serverId}`;
+    return formatServerDoctor(server, snapshot);
+  }
+
+  return [formatLspStatus(snapshot), "", "Run /lsp doctor <serverId> for resolved server details."].join("\n");
+}
+
+function formatServerDoctor(server: ServerDefinition, snapshot: LspStatusSnapshot): string {
+  const lockEntry = snapshot.lockfile.servers[server.id];
+  const processes = snapshot.processes.filter((process) => process.serverId === server.id);
+  const lines = [
+    `server: ${server.id}`,
+    `displayName: ${server.displayName}`,
+    `filetypes: ${server.filetypes.join(", ")}`,
+    `rootMarkers: ${server.rootMarkers.join(", ")}`,
+    `install: ${server.install.type}`,
+    `lazy: ${server.lazy ? "yes" : "no"}`,
+    `installed: ${lockEntry ? "yes" : "no"}`,
+  ];
+
+  if (lockEntry) {
+    lines.push(`resolvedCommand: ${lockEntry.resolvedCommand.join(" ")}`);
+    if (lockEntry.requestedVersion) lines.push(`requestedVersion: ${lockEntry.requestedVersion}`);
+    if (lockEntry.packageDir) lines.push(`packageDir: ${lockEntry.packageDir}`);
+  }
+
+  if (processes.length > 0) {
+    lines.push("processes:");
+    for (const process of processes) {
+      lines.push(`- pid ${process.pid} root=${process.rootDir} owner=${process.ownerId}`);
+    }
+  } else {
+    lines.push("processes: none");
+  }
+
+  const relevantWarnings = snapshot.config.warnings.filter((warning) => warning.includes(server.id));
+  if (relevantWarnings.length > 0) {
+    lines.push("warnings:");
+    for (const warning of relevantWarnings) lines.push(`- ${warning}`);
+  }
+
+  return lines.join("\n");
+}

package/src/config/loadConfig.ts

@@ -0,0 +1,377 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute, relative, resolve } from "node:path";
+import { isNodeError, isPlainObject, isPythonServerId, messageFromError } from "../util/helpers.js";
+import { BUILTIN_CATALOG } from "../registry/builtin.js";
+import { parseServerDefinition } from "../registry/schema.js";
+import type { Catalog, InstallMode, ServerDefinition } from "../registry/schema.js";
+import { deepClone, deepMerge } from "../util/deepMerge.js";
+import { getProjectConfigPath, getUserConfigPath } from "./paths.js";
+import { isProjectTrusted } from "./trust.js";
+
+export interface LoadLspConfigInput {
+  cwd: string;
+  projectRoot?: string;
+}
+
+export interface LoadLspConfigResult {
+  catalog: Catalog;
+  warnings: string[];
+  installMode: InstallMode;
+  warmup: boolean;
+}
+
+interface RawLspConfig {
+  installMode?: unknown;
+  warmup?: unknown;
+  servers?: unknown;
+}
+
+interface ConfigSource {
+  label: string;
+  path: string;
+  kind: "global" | "project";
+  trustedProjectOverrides: boolean;
+}
+
+const INSTALL_MODES = new Set<InstallMode>(["prompt", "auto", "off"]);
+const SAFE_PROJECT_SERVER_FIELDS = new Set([
+  "filetypes",
+  "rootMarkers",
+  "settings",
+  "initializationOptions",
+  "env",
+  "cwd",
+]);
+
+const DANGEROUS_PROJECT_ENV_KEYS = new Set([
+  "PATH",
+  "PATHEXT",
+  "NODE_OPTIONS",
+  "NODE_PATH",
+  "LD_PRELOAD",
+  "LD_LIBRARY_PATH",
+  "LD_AUDIT",
+  "JAVA_TOOL_OPTIONS",
+  "JDK_JAVA_OPTIONS",
+  "CLASSPATH",
+]);
+const DANGEROUS_PROJECT_ENV_PREFIXES = ["DYLD_", "NPM_CONFIG_", "YARN_", "PNPM_"];
+
+export async function loadLspConfig(input: LoadLspConfigInput): Promise<LoadLspConfigResult> {
+  const warnings: string[] = [];
+  const catalog = deepClone(BUILTIN_CATALOG);
+  let installMode: InstallMode = "prompt";
+  let warmup = true;
+  const projectRoot = input.projectRoot ?? input.cwd;
+  const projectTrusted = await isProjectTrusted(projectRoot);
+
+  const sources: ConfigSource[] = [
+    {
+      label: "global config",
+      path: getUserConfigPath(),
+      kind: "global",
+      trustedProjectOverrides: true,
+    },
+    {
+      label: "project config",
+      path: getProjectConfigPath(projectRoot),
+      kind: "project",
+      trustedProjectOverrides: projectTrusted,
+    },
+  ];
+
+  for (const source of sources) {
+    const config = await readConfig(source, warnings);
+    if (!config) continue;
+
+    installMode = mergeInstallMode(installMode, config.installMode, source, projectRoot, warnings);
+    warmup = mergeWarmup(warmup, config.warmup, source, projectRoot, warnings);
+    mergeServers(catalog, config.servers, source, projectRoot, warnings);
+  }
+
+  return { catalog, warnings, installMode, warmup };
+}
+
+async function readConfig(source: ConfigSource, warnings: string[]): Promise<RawLspConfig | undefined> {
+  let raw: string;
+  try {
+    raw = await readFile(source.path, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return undefined;
+    }
+    warnings.push(`Could not read ${source.label} at ${source.path}: ${messageFromError(error)}`);
+    return undefined;
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    warnings.push(`Could not parse ${source.label} at ${source.path}: ${messageFromError(error)}`);
+    return undefined;
+  }
+
+  if (!isPlainObject(parsed)) {
+    warnings.push(`Ignoring ${source.label} at ${source.path}: top-level value must be an object.`);
+    return undefined;
+  }
+
+  return parsed;
+}
+
+function mergeInstallMode(
+  current: InstallMode,
+  value: unknown,
+  source: ConfigSource,
+  projectRoot: string,
+  warnings: string[],
+): InstallMode {
+  if (value === undefined) return current;
+
+  if (source.kind === "project" && !source.trustedProjectOverrides) {
+    warnings.push(
+      `Ignoring trusted-only project installMode from ${source.path}; run /lsp trust ${projectRoot} to allow project installMode overrides.`,
+    );
+    return current;
+  }
+
+  if (typeof value === "string" && INSTALL_MODES.has(value as InstallMode)) {
+    return value as InstallMode;
+  }
+
+  warnings.push(`Ignoring invalid installMode in ${source.label} at ${source.path}: expected prompt, auto, or off.`);
+  return current;
+}
+
+function mergeWarmup(
+  current: boolean,
+  value: unknown,
+  source: ConfigSource,
+  projectRoot: string,
+  warnings: string[],
+): boolean {
+  if (value === undefined) return current;
+
+  if (source.kind === "project" && !source.trustedProjectOverrides) {
+    warnings.push(
+      `Ignoring trusted-only project warmup from ${source.path}; run /lsp trust ${projectRoot} to allow project warmup overrides.`,
+    );
+    return current;
+  }
+
+  if (typeof value === "boolean") {
+    return value;
+  }
+
+  warnings.push(`Ignoring invalid warmup in ${source.label} at ${source.path}: expected true or false.`);
+  return current;
+}
+
+function mergeServers(
+  catalog: Catalog,
+  servers: unknown,
+  source: ConfigSource,
+  projectRoot: string,
+  warnings: string[],
+): void {
+  if (servers === undefined) return;
+  if (!isPlainObject(servers)) {
+    warnings.push(`Ignoring servers in ${source.label} at ${source.path}: expected an object.`);
+    return;
+  }
+
+  for (const [serverId, rawOverride] of Object.entries(servers)) {
+    if (!isPlainObject(rawOverride)) {
+      warnings.push(`Ignoring ${serverId} in ${source.label} at ${source.path}: server override must be an object.`);
+      continue;
+    }
+
+    const override =
+      source.kind === "project" && !source.trustedProjectOverrides
+        ? filterUntrustedProjectServerFields(serverId, rawOverride, source, projectRoot, warnings)
+        : rawOverride;
+
+    const base = catalog.servers[serverId];
+    const merged = enforceCatalogKeyId(
+      mergeServerDefinition(base, serverId, override),
+      serverId,
+      override,
+      source,
+      warnings,
+    );
+    const parsed = parseServerDefinition(merged);
+    if (!parsed.ok) {
+      warnings.push(
+        `Ignoring invalid ${serverId} server definition from ${source.label} at ${source.path}: ${parsed.errors.join("; ")}.`,
+      );
+      continue;
+    }
+
+    catalog.servers[serverId] = parsed.value;
+  }
+}
+
+function mergeServerDefinition(
+  base: ServerDefinition | undefined,
+  serverId: string,
+  override: Record<string, unknown>,
+): unknown {
+  const baseForMerge = deepClone((base ?? { id: serverId }) as unknown as Record<string, unknown>);
+
+  if (
+    base &&
+    isPlainObject(baseForMerge) &&
+    isPlainObject(baseForMerge.install) &&
+    isPlainObject(override.install) &&
+    typeof override.install.type === "string" &&
+    override.install.type !== base.install.type
+  ) {
+    baseForMerge.install = {};
+  }
+
+  return normalizeServerDefinitionShorthand(deepMerge(baseForMerge, override), override);
+}
+
+function normalizeServerDefinitionShorthand(merged: unknown, override: Record<string, unknown>): unknown {
+  if (!isPlainObject(merged)) return merged;
+
+  if (isPlainObject(merged.install) && merged.install.type === "system") {
+    if (merged.command === undefined && Array.isArray(merged.install.command)) {
+      return { ...merged, command: deepClone(merged.install.command) };
+    }
+
+    if (override.command === undefined && Array.isArray(merged.install.command)) {
+      return { ...merged, command: deepClone(merged.install.command) };
+    }
+  }
+
+  return merged;
+}
+
+function filterUntrustedProjectServerFields(
+  serverId: string,
+  override: Record<string, unknown>,
+  source: ConfigSource,
+  projectRoot: string,
+  warnings: string[],
+): Record<string, unknown> {
+  const filtered: Record<string, unknown> = {};
+
+  for (const [key, value] of Object.entries(override)) {
+    if (!SAFE_PROJECT_SERVER_FIELDS.has(key)) {
+      warnings.push(ignoredProjectServerFieldWarning(serverId, key, source.path, projectRoot));
+      continue;
+    }
+
+    if (key === "env") {
+      const sanitizedEnv = filterUntrustedProjectEnv(serverId, value, source.path, warnings);
+      if (sanitizedEnv !== undefined) filtered.env = sanitizedEnv;
+      continue;
+    }
+
+    if (key === "cwd") {
+      const sanitizedCwd = filterUntrustedProjectCwd(serverId, value, source.path, projectRoot, warnings);
+      if (sanitizedCwd !== undefined) filtered.cwd = sanitizedCwd;
+      continue;
+    }
+
+    filtered[key] = deepClone(value);
+  }
+
+  return filtered;
+}
+
+function enforceCatalogKeyId(
+  definition: unknown,
+  serverId: string,
+  override: Record<string, unknown>,
+  source: ConfigSource,
+  warnings: string[],
+): unknown {
+  if (!isPlainObject(definition)) return definition;
+
+  if (typeof override.id === "string" && override.id !== serverId) {
+    warnings.push(
+      `Ignoring ${source.label} id override for ${serverId} from ${source.path}; catalog keys are authoritative.`,
+    );
+  }
+
+  return { ...definition, id: serverId };
+}
+
+function filterUntrustedProjectEnv(
+  serverId: string,
+  value: unknown,
+  sourcePath: string,
+  warnings: string[],
+): Record<string, string> | unknown {
+  if (!isPlainObject(value)) return deepClone(value);
+
+  const filtered: Record<string, string> = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (isDangerousProjectEnvKey(serverId, key)) {
+      warnings.push(
+        `Ignoring untrusted project env override for ${serverId}.${key} from ${sourcePath}; process-affecting environment variables require /lsp trust.`,
+      );
+      continue;
+    }
+    filtered[key] = deepClone(entry) as string;
+  }
+
+  return filtered;
+}
+
+function filterUntrustedProjectCwd(
+  serverId: string,
+  value: unknown,
+  sourcePath: string,
+  projectRoot: string,
+  warnings: string[],
+): string | unknown | undefined {
+  if (typeof value !== "string") return deepClone(value);
+
+  if (isAbsolute(value)) {
+    warnings.push(
+      `Ignoring untrusted project cwd override for ${serverId} from ${sourcePath}; cwd must be relative to the project root.`,
+    );
+    return undefined;
+  }
+
+  const resolvedCwd = resolve(projectRoot, value);
+  const relativeCwd = relative(projectRoot, resolvedCwd);
+  if (relativeCwd.startsWith("..") || isAbsolute(relativeCwd)) {
+    warnings.push(
+      `Ignoring untrusted project cwd override for ${serverId} from ${sourcePath}; cwd must stay inside the project root.`,
+    );
+    return undefined;
+  }
+
+  return value;
+}
+
+function isDangerousProjectEnvKey(serverId: string, key: string): boolean {
+  const upperKey = key.toUpperCase();
+  if (upperKey === "PYTHONPATH") return !isPythonServerId(serverId);
+  return (
+    DANGEROUS_PROJECT_ENV_KEYS.has(upperKey) ||
+    DANGEROUS_PROJECT_ENV_PREFIXES.some((prefix) => upperKey.startsWith(prefix))
+  );
+}
+
+function ignoredProjectServerFieldWarning(
+  serverId: string,
+  field: string,
+  sourcePath: string,
+  projectRoot: string,
+): string {
+  if (field === "command") {
+    return `Ignoring trusted-only project override for ${serverId}.command from ${sourcePath}; run /lsp trust ${projectRoot} to allow executable overrides.`;
+  }
+
+  if (field === "install") {
+    return `Ignoring trusted-only project override for ${serverId}.install from ${sourcePath}; install commands, package names, and package versions require /lsp trust ${projectRoot}.`;
+  }
+
+  return `Ignoring trusted-only project override for ${serverId}.${field} from ${sourcePath}; only filetypes, rootMarkers, settings, initializationOptions, env, and cwd are allowed before /lsp trust ${projectRoot}.`;
+}