@hienlh/ppm 0.23.6 → 0.23.7

package/src/services/jsonl-transcript-parser.ts

@@ -9,6 +9,8 @@ import { homedir } from "node:os";
 import type { ChatEvent, ChatMessage } from "../types/chat.ts";
 import { stringifyToolResultContent } from "../shared/tool-result-content.ts";
 import { stripSharedContext } from "../shared/provider-context.ts";
+import { readLines } from "./read-lines.ts";
+import { readCompactions, applyCompactions } from "./compaction-savings.ts";
 
 /**
  * How large a transcript this module will look at, for the callers that go
@@ -307,48 +309,6 @@ export function validateJsonlPath(inputPath: string, maxBytes = MAX_FILE_SIZE):
   return real;
 }
 
-/**
- * Yield a file's lines without holding the file in memory.
- *
- * `Bun.file().text()` plus `split("\n")` costs the whole transcript twice over —
- * 277MB resident for a 77MB file, which is what forced a cap low enough to
- * reject real sessions. Peak here is one chunk plus one line.
- */
-async function* readLines(filePath: string, fromByte = 0): AsyncGenerator<string> {
-  const decoder = new TextDecoder();
-  // Explicit reader rather than `for await` over the stream: the DOM lib's
-  // ReadableStream is not typed as async-iterable, and the `finally` is what
-  // releases it when a caller breaks early on `beforeUuid`.
-  // One byte *before* the offset, so the first line the split produces is
-  // always the tail of the record the offset fell inside — the empty string
-  // when it fell exactly on a newline. That makes the drop below unconditional
-  // instead of a boundary case, and a boundary case here silently costs a whole
-  // record rather than a fragment.
-  const file = fromByte > 0 ? Bun.file(filePath).slice(fromByte - 1) : Bun.file(filePath);
-  const reader = file.stream().getReader();
-  // A fragment is not always unparseable — the tail of one record is sometimes
-  // a complete smaller document — so it has to go by position rather than be
-  // left for `JSON.parse` to reject, or it enters as an invented message.
-  let dropPartial = fromByte > 0;
-  let buffered = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffered += decoder.decode(value, { stream: true });
-      const lines = buffered.split("\n");
-      buffered = lines.pop() ?? "";
-      for (const line of lines) {
-        if (dropPartial) { dropPartial = false; continue; }
-        yield line;
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  buffered += decoder.decode();
-  if (buffered && !dropPartial) yield buffered;
-}
 
 /**
  * Read a JSONL transcript file, parse entries, apply merge/nest pipeline, return ChatMessage[].
@@ -418,6 +378,11 @@ export async function parseJsonlTranscript(
   const { mergeSubagentChildren } = await import("./subagent-transcript-merger.ts");
   mergeSubagentChildren(filePath.replace(/\.jsonl$/, ""), merged);
 
+  // An expanded segment opens with its own compact summary, so it needs the same
+  // divider the newest one gets — otherwise only the last compaction in a chat is
+  // labelled and the earlier ones read as ordinary messages.
+  applyCompactions(merged, await readCompactions(filePath).catch(() => new Map()));
+
   return merged.filter(
     (msg) => msg.content.trim().length > 0 || (msg.events && msg.events.length > 0),
   );

package/src/services/lsp/lsp-install.ts

@@ -0,0 +1,289 @@
+/**
+ * Installing a language server, when someone presses Install.
+ *
+ * Nothing here runs because a file was opened. The editor says which server is missing and
+ * offers the button; pressing it is the consent, and that is the whole difference between this
+ * and an editor that fetches a binary off the network on its own.
+ *
+ * Four decisions worth keeping:
+ *
+ * - **Into `<ppm dir>/lsp-servers`, never `-g` and never `~/go/bin`.** A global
+ *   `bun add typescript@5` replaces whatever TypeScript the user had installed globally, and a
+ *   global bin directory is only found when it happens to be on the *service's* PATH — which
+ *   for a systemd-started PPM is four entries and nothing of the sort. PPM's own directory is
+ *   neither, `PPM_HOME` already isolates it for tests, and deleting it is the whole uninstall.
+ *   `rustup` is the one exception, below.
+ * - **The packages come from the registry, by server id.** Nothing the browser sends is ever
+ *   part of a command, so the route cannot be talked into installing something else.
+ * - **PPM installs servers, never toolchains.** `go install` needs a Go and
+ *   `rustup component add` needs a rustup; where the host has neither, there is no button at
+ *   all rather than one that fails when pressed.
+ * - **The directory gets a `package.json` before `bun add` runs.** Measured: `bun add` in a
+ *   directory with no manifest does not create one there — it walks *up* to the nearest parent
+ *   that has one and installs into that, leaving the directory it was asked about empty.
+ */
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { resolveBunPath } from "../autostart-generator.ts";
+import { getPpmDir } from "../ppm-dir.ts";
+import {
+  installedBinaryPath,
+  installedServerEntry,
+  packageName,
+  type LanguageServerDefinition,
+  type LanguageServerInstall,
+} from "./server-registry.ts";
+
+/** Generous: a cold `go install` builds the server from source. 10.6 s here, minutes elsewhere. */
+const INSTALL_TIMEOUT_MS = 5 * 60_000;
+/** `rustup which` is a lookup, not work. Measured at 3 ms; anything near this is a hung host. */
+const QUERY_TIMEOUT_MS = 10_000;
+
+/** Where the Install button puts servers. Inside the PPM dir, so `PPM_HOME` isolates it. */
+export function lspInstallDir(): string {
+  return path.join(getPpmDir(), "lsp-servers");
+}
+
+export interface RunResult {
+  code: number;
+  stdout: string;
+  stderr: string;
+}
+
+/**
+ * How this module runs a command.
+ *
+ * One injectable seam for all of it, so a test can drive an install with no toolchain on the
+ * machine — and named rather than `typeof Bun.spawn`, whose type widens the pipes back to a
+ * union with a raw file descriptor that `new Response()` will not take.
+ */
+export type Runner = (
+  cmd: string[],
+  options: { cwd: string; env?: Record<string, string | undefined>; timeoutMs: number },
+) => Promise<RunResult>;
+
+const runCommand: Runner = async (cmd, { cwd, env, timeoutMs }) => {
+  const proc = Bun.spawn(cmd, { cwd, env: env as Record<string, string> | undefined, stdout: "pipe", stderr: "pipe" });
+  const timer = setTimeout(() => proc.kill(), timeoutMs);
+  // Drained while it runs: a pipe nobody reads fills up, and a full pipe blocks the child
+  // instead of failing it, so awaiting the exit first can wait forever on a noisy install.
+  const [code, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+  clearTimeout(timer);
+  return { code, stdout, stderr };
+};
+
+/**
+ * The binary that would carry out this plan, or null where the host has none.
+ *
+ * The lookup is `PATH`, deliberately: it is the same PATH a language server PPM starts will
+ * inherit, so a host where PPM cannot see the Go toolchain is also a host where gopls could
+ * not run `go list`. Offering the button there would install a server that cannot work.
+ */
+export function installToolPath(plan: LanguageServerInstall): string | null {
+  if (plan.with === "bun") {
+    try {
+      return resolveBunPath();
+    } catch {
+      return null; // a compiled PPM on a host with no bun
+    }
+  }
+  // The PATH is passed explicitly because `Bun.which` otherwise reads the one the *process
+  // started with* and never looks at `process.env.PATH` again — measured: adding a directory to
+  // it changes nothing, and neither does emptying it. The tool is then spawned by the absolute
+  // path this returns, so the lookup and the run can never disagree.
+  return Bun.which(plan.with === "go" ? "go" : "rustup", { PATH: process.env.PATH ?? "" });
+}
+
+/** Whether the Install button can work here. The editor draws the button from this. */
+export function canInstall(definition: LanguageServerDefinition): boolean {
+  return definition.install ? installToolPath(definition.install) !== null : false;
+}
+
+/**
+ * Where rustup says this server is, or null when the component is not installed.
+ *
+ * `rustup which` is both the lookup and the installed-check, and it has to be: the proxy in
+ * `~/.cargo/bin` exists whether or not the component does — measured on this host, with no
+ * rust-analyzer installed, `~/.cargo/bin/rust-analyzer` is right there pointing at rustup — so
+ * a path test would report a server that cannot start. It answers in 3 ms, and it answers for
+ * the toolchain `cwd` selects, which a symlink made at install time could not.
+ */
+export async function rustupServerPath(
+  definition: LanguageServerDefinition,
+  cwd: string,
+  run: Runner = runCommand,
+): Promise<string | null> {
+  if (definition.install?.with !== "rustup") return null;
+  const rustup = installToolPath(definition.install);
+  if (!rustup) return null;
+  try {
+    const result = await run([rustup, "which", definition.command], { cwd, timeoutMs: QUERY_TIMEOUT_MS });
+    const found = result.stdout.trim();
+    return result.code === 0 && found ? found : null;
+  } catch {
+    return null;
+  }
+}
+
+/** One at a time: every install and uninstall shares one `package.json`, lockfile and toolchain. */
+let queue: Promise<unknown> = Promise.resolve();
+/** Keyed by operation *and* id, so a second Uninstall click joins that uninstall — never an install. */
+const inFlight = new Map<string, Promise<void>>();
+
+/**
+ * Install one server, and resolve once it is really there.
+ *
+ * Two clicks on one button — a second tab, an impatient user — join the same install rather
+ * than starting a second one over the first one's lockfile.
+ */
+export function installLanguageServer(
+  definition: LanguageServerDefinition,
+  options: { projectPath?: string; run?: Runner } = {},
+): Promise<void> {
+  return enqueue(`install:${definition.id}`, () => install(definition, options.projectPath, options.run ?? runCommand));
+}
+
+/**
+ * Remove one server, running the exact inverse of what installed it.
+ *
+ * Offered only for a server PPM itself put there, which is a question about where it was
+ * *found* rather than about what is on this machine — `lsp-manager.availability` answers it
+ * with `origin`, and the route gates on that. A copy on `PATH` is the user's, one in a
+ * project's `node_modules` is the repository's, and the one PPM ships is its own dependency:
+ * deleting any of the three would be PPM tidying up after someone else.
+ *
+ * rustup is again the exception that reaches outside PPM's directory, for the same reason
+ * installing it did — the component belongs to a toolchain and there is no copy of PPM's to
+ * delete. Removing it is one `rustup component add` away from being back.
+ */
+export function uninstallLanguageServer(
+  definition: LanguageServerDefinition,
+  options: { projectPath?: string; run?: Runner } = {},
+): Promise<void> {
+  return enqueue(`uninstall:${definition.id}`, () => uninstall(definition, options.projectPath, options.run ?? runCommand));
+}
+
+function enqueue(key: string, work: () => Promise<void>): Promise<void> {
+  const existing = inFlight.get(key);
+  if (existing) return existing;
+
+  const started = queue.then(work);
+  queue = started.catch(() => {}); // a failure must not poison the queue behind it
+  const tracked = started.finally(() => inFlight.delete(key));
+  inFlight.set(key, tracked);
+  return tracked;
+}
+
+async function install(definition: LanguageServerDefinition, projectPath: string | undefined, run: Runner): Promise<void> {
+  const plan = definition.install;
+  if (!plan) throw new Error(`PPM cannot install ${definition.displayName}`);
+  const tool = installToolPath(plan);
+  if (!tool) {
+    throw new Error(`${plan.with} is not installed on this host, so PPM cannot install ${definition.displayName}.`);
+  }
+
+  const dir = lspInstallDir();
+  const failed = (result: RunResult, what: string) => new Error(`${what} failed to install: ${output(result)}`);
+
+  if (plan.with === "bun") {
+    ensureInstallDir(dir);
+    const result = await run([tool, "add", ...plan.packages], { cwd: dir, timeoutMs: INSTALL_TIMEOUT_MS });
+    if (result.code !== 0) throw failed(result, plan.packages.join(" "));
+    // bun can succeed and still leave nothing to run — a package that dropped its binary, or a
+    // name that now points somewhere else. Saying so beats a second "not installed".
+    if (!installedServerEntry(definition, dir)) {
+      throw new Error(`Installed ${plan.packages.join(" ")}, but it provides no ${definition.command}`);
+    }
+    return;
+  }
+
+  if (plan.with === "go") {
+    const binDir = path.join(dir, "bin");
+    mkdirSync(binDir, { recursive: true });
+    // `GOBIN` is the whole reason this lands in PPM's directory rather than `~/go/bin`. The
+    // module and build caches stay where the user's Go already keeps them — those are the
+    // toolchain's, and re-downloading the world into the PPM directory would be rude.
+    const result = await run([tool, "install", plan.module], {
+      cwd: dir,
+      env: { ...process.env, GOBIN: binDir },
+      timeoutMs: INSTALL_TIMEOUT_MS,
+    });
+    if (result.code !== 0) throw failed(result, plan.module);
+    const built = installedBinaryPath(definition, dir);
+    if (!built || !existsSync(built)) {
+      throw new Error(`Built ${plan.module}, but no ${definition.command} appeared in ${binDir}`);
+    }
+    return;
+  }
+
+  // rustup. Run where the project is, so a repository pinned to its own toolchain gets the
+  // component added to *that* one rather than to whichever is default.
+  const cwd = projectPath && existsSync(projectPath) ? projectPath : process.cwd();
+  const result = await run([tool, "component", "add", plan.component], { cwd, timeoutMs: INSTALL_TIMEOUT_MS });
+  if (result.code !== 0) throw failed(result, plan.component);
+  if (!(await rustupServerPath(definition, cwd, run))) {
+    throw new Error(`rustup reported success but still has no ${definition.command} for this toolchain`);
+  }
+}
+
+async function uninstall(definition: LanguageServerDefinition, projectPath: string | undefined, run: Runner): Promise<void> {
+  const plan = definition.install;
+  // Both of these are the route's job to prevent; they are here because this function deletes
+  // things, and "the caller checked" is not a property a deleting function should rely on.
+  if (!plan) throw new Error(`PPM did not install ${definition.displayName}, so there is nothing to remove.`);
+  const dir = lspInstallDir();
+
+  if (plan.with === "bun") {
+    if (!installedServerEntry(definition, dir)) {
+      throw new Error(`${definition.displayName} is not in PPM's own folder, so there is nothing for PPM to remove.`);
+    }
+    const tool = installToolPath(plan);
+    if (!tool) throw new Error(`bun is not installed on this host, so PPM cannot remove ${definition.displayName}.`);
+    // By name, never by the spec that installed it: `bun remove typescript@5` is not the same
+    // request as `bun remove typescript`, and the manifest holds the name.
+    const names = plan.packages.map(packageName);
+    const result = await run([tool, "remove", ...names], { cwd: dir, timeoutMs: INSTALL_TIMEOUT_MS });
+    if (result.code !== 0) throw new Error(`Could not remove ${names.join(" ")}: ${output(result)}`);
+    return;
+  }
+
+  if (plan.with === "go") {
+    const binary = installedBinaryPath(definition, dir);
+    if (!binary || !existsSync(binary)) {
+      throw new Error(`${definition.displayName} is not in PPM's own folder, so there is nothing for PPM to remove.`);
+    }
+    try {
+      rmSync(binary);
+    } catch (e) {
+      // Windows refuses to unlink a running executable, which is the one platform where an
+      // uninstall fails for a reason the user can act on.
+      throw new Error(`Could not delete ${binary}: ${(e as Error).message}`);
+    }
+    return;
+  }
+
+  // rustup, in the same directory the install would have used, so the component leaves the
+  // toolchain it was added to rather than whichever happens to be default.
+  const cwd = projectPath && existsSync(projectPath) ? projectPath : process.cwd();
+  const tool = installToolPath(plan);
+  if (!tool) throw new Error(`rustup is not installed on this host, so PPM cannot remove ${definition.displayName}.`);
+  const result = await run([tool, "component", "remove", plan.component], { cwd, timeoutMs: INSTALL_TIMEOUT_MS });
+  if (result.code !== 0) throw new Error(`Could not remove ${plan.component}: ${output(result)}`);
+}
+
+/** What a failed command said, bounded — a build log's last 400 characters hold the reason. */
+function output(result: RunResult): string {
+  return (result.stderr.trim() || result.stdout.trim()).slice(-400) || `exit ${result.code}`;
+}
+
+function ensureInstallDir(dir: string): void {
+  mkdirSync(dir, { recursive: true });
+  const manifest = path.join(dir, "package.json");
+  if (!existsSync(manifest)) {
+    writeFileSync(manifest, `${JSON.stringify({ name: "ppm-lsp-servers", private: true, dependencies: {} }, null, 2)}\n`);
+  }
+}

package/src/services/lsp/lsp-manager.ts

@@ -16,14 +16,20 @@
  */
 import { stat } from "node:fs/promises";
 import path from "node:path";
+import { resolveBunPath } from "../autostart-generator.ts";
+import { canInstall, lspInstallDir, rustupServerPath } from "./lsp-install.ts";
 import { LspSession, type LspSessionState } from "./lsp-session.ts";
 import {
   LANGUAGE_SERVERS,
   ancestorDirs,
   bundledServerEntry,
   candidateCommandPaths,
+  installedBinaryPath,
+  installedServerEntry,
   lspLanguageForPath,
+  serversSharingInstall,
   type LanguageServerDefinition,
+  type LanguageServerInstall,
 } from "./server-registry.ts";
 
 /** How long a session with no subscribers is kept before being shut down. */
@@ -52,10 +58,34 @@ export type LspUnavailableReason = "no-language" | "not-installed" | "failed";
 export interface LspUnavailable {
   reason: LspUnavailableReason;
   /** The server that would have served it, when one is known. */
-  server?: { id: string; displayName: string; installHint: string };
+  server?: {
+    id: string;
+    displayName: string;
+    installHint: string;
+    installable: boolean;
+    /** What the button would use, so the editor can say what pressing it does. */
+    installWith?: "bun" | "go" | "rustup";
+  };
   message: string;
 }
 
+/**
+ * What the editor needs to name a missing server, and to decide whether to offer to install it.
+ *
+ * `installable` is the host's answer rather than the editor's guess, and it is not the registry's
+ * either: `go install` needs a Go on this machine and `rustup component add` needs a rustup, so
+ * the same server is installable on one host and a command to copy on the next.
+ */
+function serverSummary(definition: LanguageServerDefinition): NonNullable<LspUnavailable["server"]> {
+  return {
+    id: definition.id,
+    displayName: definition.displayName,
+    installHint: definition.installHint,
+    installable: canInstall(definition),
+    installWith: definition.install?.with,
+  };
+}
+
 export function isUnavailable(result: LspHandle | LspUnavailable): result is LspUnavailable {
   return "reason" in result;
 }
@@ -68,6 +98,33 @@ interface Entry {
   lastUsed: number;
 }
 
+/**
+ * The bun that runs a server's entry script.
+ *
+ * Not `process.execPath`: that is bun only while PPM runs from source. A compiled PPM is its
+ * own executable, so spawning it with a script path reaches PPM's *CLI* — the same trap that
+ * made a compiled PPM answer `<ppm> x @openai/codex app-server` with "unknown command". `null`
+ * on a host with no bun at all, where such a copy cannot be run and must not be called
+ * installed.
+ */
+function bunRuntime(): string | null {
+  try {
+    return resolveBunPath();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Where a server was found, in the order `resolveCommand` looks.
+ *
+ * It exists for the Remove button: PPM may delete what PPM installed and nothing else.
+ * `project` is the repository's copy, `path` is one the user installed themselves, and
+ * `bundled` is PPM's own dependency — removing any of those would be PPM tidying up after
+ * someone else, and for `bundled` it would break the TypeScript server a fresh install has.
+ */
+export type ServerOrigin = "project" | "rustup" | "path" | "ppm" | "bundled";
+
 async function exists(candidate: string): Promise<boolean> {
   try {
     await stat(candidate);
@@ -107,6 +164,8 @@ export class LspManager {
     private readonly servers: LanguageServerDefinition[] = LANGUAGE_SERVERS,
     private readonly idleGraceMs: number = IDLE_GRACE_MS,
     private readonly maxSessions: number = MAX_SESSIONS,
+    /** Called rather than held, so `PPM_HOME` is read when a server is looked for, not at import. */
+    private readonly installDir: () => string = lspInstallDir,
   ) {}
 
   onNotification(listener: (key: string, method: string, params: unknown) => void): () => void {
@@ -136,8 +195,8 @@ export class LspManager {
 
     let lastMissing: LanguageServerDefinition | null = null;
     for (const definition of candidates) {
-      const command = await this.resolveCommand(definition, dirs);
-      if (!command) {
+      const resolved = await this.resolveCommand(definition, dirs);
+      if (!resolved) {
         lastMissing = definition;
         continue;
       }
@@ -146,7 +205,7 @@ export class LspManager {
 
       this.claim(key);
       try {
-        const session = await this.startOrReuse(key, definition, command, rootPath);
+        const session = await this.startOrReuse(key, definition, resolved.command, rootPath);
         // Subscribe *then* trim, so the session this call is about to hand out is never the
         // one the cap takes away.
         if (!this.subscribe(key, subscriber)) {
@@ -161,7 +220,7 @@ export class LspManager {
       } catch (e) {
         return {
           reason: "failed",
-          server: { id: definition.id, displayName: definition.displayName, installHint: definition.installHint },
+          server: serverSummary(definition),
           message: e instanceof Error ? e.message : String(e),
         };
       } finally {
@@ -172,7 +231,7 @@ export class LspManager {
     const missing = lastMissing ?? candidates[0]!;
     return {
       reason: "not-installed",
-      server: { id: missing.id, displayName: missing.displayName, installHint: missing.installHint },
+      server: serverSummary(missing),
       message: `${missing.displayName} is not installed.`,
     };
   }
@@ -322,25 +381,51 @@ export class LspManager {
    *
    * The project's own copy first, because a repository pinned to TypeScript 4 has to be
    * analysed by its own server — the same reason VS Code offers "Use Workspace Version".
-   * Then `PATH`, which is whatever the user deliberately installed. Then the copy PPM ships,
-   * which is the floor rather than a preference: it is how a fresh install has a working
-   * TypeScript server with nothing else done, and it must never win over either of the two
-   * choices someone actually made.
+   * Then rustup, which owns its answer completely (below). Then `PATH`, which is whatever the
+   * user deliberately installed. Then PPM's own directory: what the Install button put there,
+   * and then the copy PPM ships, which is the floor rather than a preference — it is how a
+   * fresh install has a working TypeScript server with nothing else done, and it must never win
+   * over either of the two choices someone actually made.
    */
-  private async resolveCommand(definition: LanguageServerDefinition, dirs: string[]): Promise<string[] | null> {
+  private async resolveCommand(
+    definition: LanguageServerDefinition,
+    dirs: string[],
+  ): Promise<{ command: string[]; origin: ServerOrigin } | null> {
     const candidates = candidateCommandPaths(definition.command, dirs);
     for (const candidate of candidates.slice(0, -1)) {
-      if (await exists(candidate)) return [candidate];
+      if (await exists(candidate)) return { command: [candidate], origin: "project" };
     }
+    // rust-analyzer is a toolchain component rather than a file PPM owns, so rustup is asked
+    // where it is — in the file's own directory, so a repository pinning a toolchain gets that
+    // toolchain's server. This has to come *before* PATH, because `~/.cargo/bin/rust-analyzer`
+    // is a rustup proxy that exists whether or not the component does: found on PATH it reports
+    // an installed server, and spawning it prints "unknown binary" and exits, which is a broken
+    // server rather than the missing one the Install button is offered for. Costs nothing for
+    // every other server — it answers null on sight of a definition that is not rustup's.
+    const fromRustup = await rustupServerPath(definition, dirs[0] ?? process.cwd());
+    if (fromRustup) return { command: [fromRustup], origin: "rustup" };
+
     // The last candidate is the bare command, which means PATH.
     const onPath = Bun.which(definition.command);
-    if (onPath) return [onPath];
+    if (onPath) return { command: [onPath], origin: "path" };
+
+    // What the Install button built with the host's Go: a real binary in PPM's own directory,
+    // spawned as itself.
+    const binary = installedBinaryPath(definition, this.installDir());
+    if (binary && (await exists(binary))) return { command: [binary], origin: "ppm" };
 
-    const bundled = bundledServerEntry(definition);
-    // Run by the runtime PPM is already using, not through npm's `.bin` shim: that shim is
+    // Both of PPM's npm copies are entry scripts rather than npm's `.bin` shims: that shim is
     // `#!/usr/bin/env node`, and someone who installed PPM with bun may have no node at all —
     // which fails as exit code 127 at spawn time, long after the server looked installed.
-    return bundled && (await exists(bundled)) ? [process.execPath, bundled] : null;
+    for (const [entry, origin] of [
+      [installedServerEntry(definition, this.installDir()), "ppm"],
+      [bundledServerEntry(definition), "bundled"],
+    ] as const) {
+      if (!entry || !(await exists(entry))) continue;
+      const runtime = bunRuntime();
+      return runtime ? { command: [runtime, entry], origin } : null;
+    }
+    return null;
   }
 
   /**
@@ -382,24 +467,70 @@ export class LspManager {
   }
 
   /**
-   * Which of the registered servers this project could actually use.
+   * Which of the registered servers could actually be used.
    *
-   * Answers the editor's "why is nothing happening" question directly, with the
-   * install command for anything missing.
+   * Answers the editor's "why is nothing happening" question directly, with the install
+   * command for anything missing. With no `projectPath` it answers for the *machine* — no
+   * project `node_modules/.bin` is consulted — which is what the Settings pane asks, since it
+   * is not open on any one project.
    */
-  async availability(projectPath: string): Promise<
-    Array<{ id: string; displayName: string; languages: string[]; installed: boolean; installHint: string }>
+  async availability(projectPath?: string): Promise<
+    Array<{
+      id: string;
+      displayName: string;
+      languages: string[];
+      installed: boolean;
+      installHint: string;
+      installable: boolean;
+      installWith?: LanguageServerInstall["with"];
+      origin?: ServerOrigin;
+      /** Whether PPM may remove it — that is, whether PPM is what put it there. */
+      removable: boolean;
+      /** Servers the same removal would also take, because one npm package provides several. */
+      alsoRemoves?: string[];
+    }>
   > {
-    const dirs = [projectPath];
+    const dirs = projectPath ? [projectPath] : [];
     return Promise.all(
-      this.servers.map(async (definition) => ({
-        id: definition.id,
-        displayName: definition.displayName,
-        languages: definition.languages,
-        installed: (await this.resolveCommand(definition, dirs)) !== null,
-        installHint: definition.installHint,
-      })),
+      this.servers.map(async (definition) => {
+        const resolved = await this.resolveCommand(definition, dirs);
+        const origin = resolved?.origin;
+        const removable = origin === "ppm" || origin === "rustup";
+        const shared = removable ? serversSharingInstall(definition).map((s) => s.displayName) : [];
+        return {
+          id: definition.id,
+          displayName: definition.displayName,
+          languages: definition.languages,
+          installed: resolved !== null,
+          installHint: definition.installHint,
+          installable: canInstall(definition),
+          installWith: definition.install?.with,
+          origin,
+          removable,
+          ...(shared.length > 0 ? { alsoRemoves: shared } : {}),
+        };
+      }),
+    );
+  }
+
+  /**
+   * Stop this server's idle sessions, for an uninstall that is about to delete it.
+   *
+   * Only the ones nobody is holding. A session with a subscriber is an editor open on it, and
+   * taking that away answers every later request with "the language server is no longer
+   * running" until the tab is closed and reopened — the same reason `enforceSessionCap` leaves
+   * held sessions alone. One that keeps running is running on files it already opened, which
+   * is harmless everywhere except Windows, where it is also what refuses the unlink.
+   */
+  async stopIdle(serverId: string): Promise<void> {
+    const doomed = [...this.entries.entries()].filter(
+      ([, entry]) => entry.session.definition.id === serverId && entry.subscribers.size === 0,
     );
+    for (const [key, entry] of doomed) {
+      if (entry.idleTimer) clearTimeout(entry.idleTimer);
+      this.entries.delete(key);
+    }
+    await Promise.all(doomed.map(([, entry]) => entry.session.dispose()));
   }
 
   /**