pi-lsp-adapter 0.1.0

package/src/lsp/processRegistry.ts

@@ -0,0 +1,339 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { getProcessRegistryPath } from "../config/paths.js";
+import { delay, isNodeError, isPlainObject } from "../util/helpers.js";
+
+export interface LspProcessEntry {
+  id: string;
+  serverId: string;
+  rootDir: string;
+  pid: number;
+  command: string[];
+  cwd: string;
+  startedAt: string;
+  ownerId: string;
+  ownerPid: number;
+}
+
+export interface LspPidFile {
+  processes: LspProcessEntry[];
+}
+
+export interface ProcessProbe {
+  isRunning(pid: number): boolean | Promise<boolean>;
+  commandMatches(pid: number, command: string[]): boolean | Promise<boolean>;
+  terminate(pid: number, signal: NodeJS.Signals): void | Promise<void>;
+}
+
+export interface LspProcessRegistryOptions {
+  path?: string;
+  dir?: string;
+  ownerId: string;
+  probe?: ProcessProbe;
+  terminateGraceMs?: number;
+}
+
+export interface CleanupResult {
+  terminated: LspProcessEntry[];
+  removed: LspProcessEntry[];
+  kept: LspProcessEntry[];
+}
+
+export class LspProcessRegistry {
+  private readonly path: string;
+  private readonly dir: string;
+  private readonly ownerId: string;
+  private readonly probe: ProcessProbe;
+  private readonly terminateGraceMs: number;
+  private mutationQueue = Promise.resolve();
+
+  constructor(options: LspProcessRegistryOptions) {
+    this.ownerId = options.ownerId;
+    this.path = options.path ?? getProcessRegistryPath(options.ownerId);
+    this.dir = options.dir ?? dirname(this.path);
+    this.probe = options.probe ?? nodeProcessProbe;
+    this.terminateGraceMs = options.terminateGraceMs ?? 1500;
+  }
+
+  async list(): Promise<LspProcessEntry[]> {
+    return this.readAllEntries();
+  }
+
+  async register(
+    entry: Omit<LspProcessEntry, "ownerId" | "ownerPid" | "startedAt"> &
+      Partial<Pick<LspProcessEntry, "ownerId" | "ownerPid" | "startedAt">>,
+  ): Promise<void> {
+    await this.withMutation(async () => {
+      const pidFile = await this.readOwnerFile();
+      const nextEntry: LspProcessEntry = {
+        ...entry,
+        ownerId: entry.ownerId ?? this.ownerId,
+        ownerPid: entry.ownerPid ?? process.pid,
+        startedAt: entry.startedAt ?? new Date().toISOString(),
+      };
+      pidFile.processes = [...pidFile.processes.filter((item) => !isSameOwnerSlot(item, nextEntry)), nextEntry];
+      await this.writeOwnerFile(pidFile);
+    });
+  }
+
+  async unregister(id: string, pid?: number): Promise<void> {
+    await this.withMutation(async () => {
+      const pidFile = await this.readOwnerFile();
+      pidFile.processes = pidFile.processes.filter((entry) => {
+        if (entry.id !== id) return true;
+        if (pid === undefined) return false;
+        return entry.pid !== pid;
+      });
+      await this.writeOwnerFile(pidFile);
+    });
+  }
+
+  async cleanupStaleProcesses(): Promise<CleanupResult> {
+    const entries = await this.readAllEntries();
+    const result: CleanupResult = { terminated: [], removed: [], kept: [] };
+
+    for (const entry of entries) {
+      if (!(await this.probe.isRunning(entry.pid))) {
+        result.removed.push(entry);
+        continue;
+      }
+
+      if (!(await this.isStaleOwner(entry))) {
+        result.kept.push(entry);
+        continue;
+      }
+
+      if (!(await this.probe.commandMatches(entry.pid, entry.command))) {
+        result.kept.push(entry);
+        continue;
+      }
+
+      await this.terminateEntry(entry);
+      result.terminated.push(entry);
+    }
+
+    await this.rewriteAllEntries(result.kept);
+    return result;
+  }
+
+  async terminateOwnedProcesses(): Promise<CleanupResult> {
+    return this.terminateProcesses((entry) => entry.ownerId === this.ownerId);
+  }
+
+  async terminateProcesses(predicate: (entry: LspProcessEntry) => boolean = () => true): Promise<CleanupResult> {
+    const entries = await this.readAllEntries();
+    const result: CleanupResult = { terminated: [], removed: [], kept: [] };
+
+    for (const entry of entries) {
+      if (!predicate(entry)) {
+        result.kept.push(entry);
+        continue;
+      }
+
+      if (!(await this.probe.isRunning(entry.pid))) {
+        result.removed.push(entry);
+        continue;
+      }
+
+      if (!(await this.probe.commandMatches(entry.pid, entry.command))) {
+        result.kept.push(entry);
+        continue;
+      }
+
+      await this.terminateEntry(entry);
+      result.terminated.push(entry);
+    }
+
+    await this.rewriteAllEntries(result.kept);
+    return result;
+  }
+
+  private async isStaleOwner(entry: LspProcessEntry): Promise<boolean> {
+    return entry.ownerPid === process.pid || !(await this.probe.isRunning(entry.ownerPid));
+  }
+
+  private async terminateEntry(entry: LspProcessEntry): Promise<void> {
+    await this.probe.terminate(entry.pid, "SIGTERM");
+    await delay(this.terminateGraceMs);
+    if (await this.probe.isRunning(entry.pid)) {
+      await this.probe.terminate(entry.pid, "SIGKILL");
+    }
+  }
+
+  private async withMutation<T>(operation: () => Promise<T>): Promise<T> {
+    const run = this.mutationQueue.catch(() => undefined).then(operation);
+    this.mutationQueue = run.then(
+      () => undefined,
+      () => undefined,
+    );
+    return run;
+  }
+
+  private async readOwnerFile(): Promise<LspPidFile> {
+    return this.readFile(this.path);
+  }
+
+  private async readAllEntries(): Promise<LspProcessEntry[]> {
+    const files = await this.registryFiles();
+    const entries: LspProcessEntry[] = [];
+    for (const file of files) {
+      entries.push(...(await this.readFile(file)).processes);
+    }
+    return normalizePidFile({ processes: entries }).processes;
+  }
+
+  private async registryFiles(): Promise<string[]> {
+    const files = new Set<string>();
+    files.add(this.path);
+
+    try {
+      for (const entry of await readdir(this.dir, { withFileTypes: true })) {
+        if (entry.isFile() && entry.name.endsWith(".json")) {
+          files.add(join(this.dir, entry.name));
+        }
+      }
+    } catch (error) {
+      if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+    }
+
+    return [...files].sort();
+  }
+
+  private async rewriteAllEntries(entries: LspProcessEntry[]): Promise<void> {
+    const grouped = new Map<string, LspProcessEntry[]>();
+    for (const entry of entries) {
+      const filePath = this.pathForOwner(entry.ownerId);
+      grouped.set(filePath, [...(grouped.get(filePath) ?? []), entry]);
+    }
+
+    for (const filePath of await this.registryFiles()) {
+      await this.writeFile(filePath, { processes: grouped.get(filePath) ?? [] });
+      grouped.delete(filePath);
+    }
+
+    for (const [filePath, processes] of grouped) {
+      await this.writeFile(filePath, { processes });
+    }
+  }
+
+  private pathForOwner(ownerId: string): string {
+    if (ownerId === this.ownerId) return this.path;
+    return join(this.dir, `${safePathSegment(ownerId)}.json`);
+  }
+
+  private async readFile(path: string): Promise<LspPidFile> {
+    try {
+      const raw = await readFile(path, "utf8");
+      if (raw.trim() === "") return { processes: [] };
+
+      const parsed: unknown = JSON.parse(raw);
+      if (!isPidFile(parsed)) return { processes: [] };
+      return { processes: parsed.processes };
+    } catch (error) {
+      if (isNodeError(error) && error.code === "ENOENT") {
+        return { processes: [] };
+      }
+      if (error instanceof SyntaxError) {
+        return { processes: [] };
+      }
+      throw error;
+    }
+  }
+
+  private async writeOwnerFile(pidFile: LspPidFile): Promise<void> {
+    await this.writeFile(this.path, pidFile);
+  }
+
+  private async writeFile(path: string, pidFile: LspPidFile): Promise<void> {
+    await mkdir(dirname(path), { recursive: true });
+    const normalized = normalizePidFile(pidFile);
+    if (normalized.processes.length === 0) {
+      await rm(path, { force: true });
+      return;
+    }
+
+    const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+    await rename(tempPath, path);
+  }
+}
+
+export const nodeProcessProbe: ProcessProbe = {
+  isRunning(pid: number): boolean {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return isNodeError(error) && error.code === "EPERM";
+    }
+  },
+
+  async commandMatches(pid: number, command: string[]): Promise<boolean> {
+    if (process.platform !== "linux") return true;
+    const expected = command[0];
+    if (!expected) return false;
+
+    try {
+      const cmdline = await readFile(`/proc/${pid}/cmdline`, "utf8");
+      const actualParts = cmdline.split("\0").filter(Boolean);
+      const expectedBasename = expected.split("/").at(-1);
+      return actualParts.some((part) => part === expected || part.endsWith(`/${expectedBasename}`));
+    } catch {
+      return false;
+    }
+  },
+
+  terminate(pid: number, signal: NodeJS.Signals): void {
+    try {
+      process.kill(pid, signal);
+    } catch (error) {
+      if (!isNodeError(error) || error.code !== "ESRCH") throw error;
+    }
+  },
+};
+
+function normalizePidFile(pidFile: LspPidFile): LspPidFile {
+  return {
+    processes: [...pidFile.processes].sort(
+      (left, right) =>
+        left.id.localeCompare(right.id) || left.ownerId.localeCompare(right.ownerId) || left.pid - right.pid,
+    ),
+  };
+}
+
+function safePathSegment(value: string): string {
+  return value.replace(/[^A-Za-z0-9._-]/gu, "_");
+}
+
+function isSameOwnerSlot(
+  left: Pick<LspProcessEntry, "id" | "ownerId">,
+  right: Pick<LspProcessEntry, "id" | "ownerId">,
+): boolean {
+  return left.id === right.id && left.ownerId === right.ownerId;
+}
+
+function isPidFile(value: unknown): value is LspPidFile {
+  if (!isPlainObject(value) || !Array.isArray(value.processes)) return false;
+  return value.processes.every(isProcessEntry);
+}
+
+function isProcessEntry(value: unknown): value is LspProcessEntry {
+  return (
+    isPlainObject(value) &&
+    typeof value.id === "string" &&
+    typeof value.serverId === "string" &&
+    typeof value.rootDir === "string" &&
+    typeof value.pid === "number" &&
+    Number.isInteger(value.pid) &&
+    value.pid > 0 &&
+    Array.isArray(value.command) &&
+    value.command.every((entry) => typeof entry === "string") &&
+    typeof value.cwd === "string" &&
+    typeof value.startedAt === "string" &&
+    typeof value.ownerId === "string" &&
+    typeof value.ownerPid === "number" &&
+    Number.isInteger(value.ownerPid) &&
+    value.ownerPid > 0
+  );
+}