@hienlh/ppm 0.23.11 → 0.23.13

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

@@ -15,25 +15,34 @@
  *   `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.
+ * - **PPM installs servers, never toolchains.** `go install` needs a Go, `gem install` a Ruby
+ *   and `rustup component add` a rustup; where the host has none, there is no button at all
+ *   rather than one that fails when pressed. A server whose project publishes a build (clangd,
+ *   lua-language-server) needs no toolchain: the pinned release is downloaded, checked against
+ *   its SHA-256 and unpacked — and proven to start with `--version` before it counts.
  * - **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 { chmodSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { resolveBunPath } from "../autostart-generator.ts";
+import { createLogger } from "../logger.ts";
 import { getPpmDir } from "../ppm-dir.ts";
+import { downloadVerified, type FetchFn } from "../speech-to-text/whisper-download.ts";
 import {
+  gemInstallDir,
   installedBinaryPath,
   installedServerEntry,
   packageName,
+  releaseAssetFor,
   type LanguageServerDefinition,
   type LanguageServerInstall,
+  type ReleaseAsset,
 } from "./server-registry.ts";
 
+const log = createLogger("lsp");
+
 /** 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. */
@@ -64,7 +73,10 @@ export type Runner = (
 
 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);
+  const timer = setTimeout(() => {
+    log.warn(`${path.basename(cmd[0] ?? "")} ${cmd[1] ?? ""} timed out after ${Math.round(timeoutMs / 1000)}s; killed pid=${proc.pid}`);
+    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([
@@ -95,7 +107,33 @@ export function installToolPath(plan: LanguageServerInstall): string | null {
   // 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 ?? "" });
+  const which = (tool: string) => Bun.which(tool, { PATH: process.env.PATH ?? "" });
+  if (plan.with === "download") {
+    // No build for this host means no button, whatever is on PATH.
+    const asset = releaseAssetFor(plan);
+    return asset ? unpackToolPath(asset, which) : null;
+  }
+  // RubyGems writes a `.bat` binstub on Windows, which nothing here has been seen to spawn, so
+  // Windows keeps the copyable command instead of a button that might install a dead server.
+  if (plan.with === "gem") return process.platform === "win32" ? null : which("gem");
+  return which(plan.with === "go" ? "go" : "rustup");
+}
+
+/**
+ * What unpacks a release. `tar` reads a tarball everywhere, and a zip on Windows, whose
+ * `tar.exe` is bsdtar (shipped since Windows 10). Elsewhere a zip needs `unzip` or libarchive's
+ * `bsdtar`: GNU tar cannot read one, and neither can `Bun.Archive` ("Unrecognized archive format").
+ */
+function unpackToolPath(asset: ReleaseAsset, which: (tool: string) => string | null): string | null {
+  if (asset.archive === "tar.gz" || process.platform === "win32") return which("tar");
+  return which("unzip") ?? which("bsdtar");
+}
+
+function unpackCommand(tool: string, asset: ReleaseAsset, archive: string, dest: string): string[] {
+  if (asset.archive === "tar.gz") return [tool, "-xzf", archive, "-C", dest];
+  return /^unzip(\.exe)?$/i.test(path.basename(tool))
+    ? [tool, "-q", archive, "-d", dest]
+    : [tool, "-xf", archive, "-C", dest];
 }
 
 /** Whether the Install button can work here. The editor draws the button from this. */
@@ -142,9 +180,15 @@ const inFlight = new Map<string, Promise<void>>();
  */
 export function installLanguageServer(
   definition: LanguageServerDefinition,
-  options: { projectPath?: string; run?: Runner } = {},
+  options: { projectPath?: string; run?: Runner; fetchFn?: FetchFn } = {},
 ): Promise<void> {
-  return enqueue(`install:${definition.id}`, () => install(definition, options.projectPath, options.run ?? runCommand));
+  return enqueue(`install:${definition.id}`, async () => {
+    // A failure needs no line here: the route answers it with a 500, which the access log records.
+    const startedAt = performance.now();
+    log.info(`installing ${describeInstall(definition)} scope=${options.projectPath ? "project" : "global"}`);
+    await install(definition, options.projectPath, options.run ?? runCommand, options.fetchFn);
+    log.info(`installed ${describeInstall(definition)} in ${Math.round(performance.now() - startedAt)}ms`);
+  });
 }
 
 /**
@@ -164,7 +208,22 @@ export function uninstallLanguageServer(
   definition: LanguageServerDefinition,
   options: { projectPath?: string; run?: Runner } = {},
 ): Promise<void> {
-  return enqueue(`uninstall:${definition.id}`, () => uninstall(definition, options.projectPath, options.run ?? runCommand));
+  return enqueue(`uninstall:${definition.id}`, async () => {
+    await uninstall(definition, options.projectPath, options.run ?? runCommand);
+    log.info(`removed ${describeInstall(definition)}`);
+  });
+}
+
+/** `<id> via <tool> (<what it installs>)`: registry values only, never anything from a request. */
+function describeInstall(definition: LanguageServerDefinition): string {
+  const plan = definition.install;
+  if (!plan) return definition.id;
+  const target = plan.with === "bun" ? plan.packages.join(" ")
+    : plan.with === "go" ? plan.module
+    : plan.with === "gem" ? plan.gem
+    : plan.with === "download" ? plan.version
+    : plan.component;
+  return `${definition.id} via ${plan.with} (${target})`;
 }
 
 function enqueue(key: string, work: () => Promise<void>): Promise<void> {
@@ -178,12 +237,23 @@ function enqueue(key: string, work: () => Promise<void>): Promise<void> {
   return tracked;
 }
 
-async function install(definition: LanguageServerDefinition, projectPath: string | undefined, run: Runner): Promise<void> {
+async function install(
+  definition: LanguageServerDefinition,
+  projectPath: string | undefined,
+  run: Runner,
+  fetchFn?: FetchFn,
+): 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}.`);
+    throw new Error(
+      plan.with === "download"
+        ? `There is no build of ${definition.displayName} for this machine, or nothing here to unpack one.`
+        : plan.with === "gem" && process.platform === "win32"
+          ? `PPM does not install gems on Windows. Run: ${definition.installHint}`
+          : `${plan.with} is not installed on this host, so PPM cannot install ${definition.displayName}.`,
+    );
   }
 
   const dir = lspInstallDir();
@@ -201,6 +271,46 @@ async function install(definition: LanguageServerDefinition, projectPath: string
     return;
   }
 
+  if (plan.with === "download") {
+    mkdirSync(dir, { recursive: true });
+    await installRelease(definition, plan, tool, dir, run, fetchFn);
+    return;
+  }
+
+  if (plan.with === "gem") {
+    const gemDir = gemInstallDir(dir);
+    // `--install-dir` keeps the gems out of the user's own gem home and `--bindir` puts the
+    // binstub beside them rather than in a system bin directory. A GEM_HOME or GEM_PATH from
+    // the user's environment is left out, so the install does not count gems elsewhere as
+    // present and skip them — the server would then depend on folders PPM does not own.
+    const { GEM_HOME: _home, GEM_PATH: _path, ...env } = process.env;
+    mkdirSync(dir, { recursive: true });
+    const fresh = !existsSync(gemDir);
+    const result = await run(
+      [tool, "install", "--no-document", "--install-dir", gemDir, "--bindir", path.join(gemDir, "bin"), plan.gem],
+      { cwd: dir, env, timeoutMs: INSTALL_TIMEOUT_MS },
+    );
+    if (result.code !== 0) {
+      // gem leaves what it managed "for inspection"; a first install that failed has nothing
+      // worth keeping, while a working one being updated must survive its update failing.
+      if (fresh) rmSync(gemDir, { recursive: true, force: true });
+      // Its own message ends on a log path; the cause is that some dependency (prism, rbs,
+      // jaro_winkler) compiles C, and the host has no compiler — measured with one off PATH.
+      if (/Failed to build gem native extension/.test(`${result.stderr}\n${result.stdout}`)) {
+        throw new Error(
+          `${plan.gem} needs a C compiler to build one of its gems, and this host has none on PATH`
+          + ` (Linux: gcc and make; macOS: xcode-select --install). ${output(result)}`,
+        );
+      }
+      throw failed(result, plan.gem);
+    }
+    const binstub = installedBinaryPath(definition, dir);
+    if (!binstub || !existsSync(binstub)) {
+      throw new Error(`Installed ${plan.gem}, but no ${definition.command} appeared in ${path.dirname(binstub ?? gemDir)}`);
+    }
+    return;
+  }
+
   if (plan.with === "go") {
     const binDir = path.join(dir, "bin");
     mkdirSync(binDir, { recursive: true });
@@ -230,6 +340,68 @@ async function install(definition: LanguageServerDefinition, projectPath: string
   }
 }
 
+/** How long `--version` may take to prove an unpacked server starts on this host. */
+const PROBE_TIMEOUT_MS = 30_000;
+
+/**
+ * Download, verify, unpack and prove one release build, then swap it in whole.
+ *
+ * Everything happens in a staging folder beside the target, so the server folder only ever holds
+ * a complete build that has started once: a failed download, a corrupt archive or a binary that
+ * cannot run on this host (a glibc too old, the wrong architecture) leaves the previous install —
+ * or nothing — exactly as it was.
+ */
+async function installRelease(
+  definition: LanguageServerDefinition,
+  plan: Extract<LanguageServerInstall, { with: "download" }>,
+  tool: string,
+  dir: string,
+  run: Runner,
+  fetchFn?: FetchFn,
+): Promise<void> {
+  const asset = releaseAssetFor(plan);
+  if (!asset) throw new Error(`${definition.displayName} publishes no build for ${process.platform}-${process.arch}.`);
+  const name = path.posix.basename(new URL(asset.url).pathname);
+  const stage = mkdtempSync(path.join(dir, `.${definition.id}-`));
+  try {
+    const archive = path.join(stage, name);
+    await downloadVerified({ url: asset.url, dest: archive, sha256: asset.sha256, fetchFn });
+    const unpacked = path.join(stage, "release");
+    mkdirSync(unpacked);
+    const result = await run(unpackCommand(tool, asset, archive, unpacked), { cwd: stage, timeoutMs: INSTALL_TIMEOUT_MS });
+    if (result.code !== 0) throw new Error(`Could not unpack ${name}: ${output(result)}`);
+
+    const binary = path.join(unpacked, ...asset.binary.split("/"));
+    if (!existsSync(binary)) throw new Error(`${name} has no ${asset.binary}`);
+    if (process.platform !== "win32") chmodSync(binary, 0o755);
+    const probe = await run([binary, "--version"], { cwd: stage, timeoutMs: PROBE_TIMEOUT_MS });
+    if (probe.code !== 0) {
+      throw new Error(`${definition.displayName} ${plan.version} does not start on this host: ${output(probe)}`);
+    }
+
+    // Swapped by renames, never by deleting first: the working install waits in the stage until
+    // the new one is in place and goes back if it cannot be, so a rename Windows refuses (an
+    // antivirus scanning the new exe, a server still running from the old folder) costs nothing.
+    const target = path.join(dir, definition.id);
+    const previous = path.join(stage, "previous");
+    let movedAside = false;
+    try {
+      renameSync(target, previous);
+      movedAside = true;
+    } catch (e) {
+      if ((e as NodeJS.ErrnoException).code !== "ENOENT") throw e;
+    }
+    try {
+      renameSync(unpacked, target);
+    } catch (e) {
+      if (movedAside) renameSync(previous, target);
+      throw e;
+    }
+  } finally {
+    rmSync(stage, { recursive: true, force: true });
+  }
+}
+
 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
@@ -251,6 +423,22 @@ async function uninstall(definition: LanguageServerDefinition, projectPath: stri
     return;
   }
 
+  if (plan.with === "download" || plan.with === "gem") {
+    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.`);
+    }
+    // The whole release folder for a download. For a gem, the whole gem folder: it holds the
+    // server's dependencies too, and solargraph is the only gem plan (a test keeps it so).
+    const folder = plan.with === "download" ? path.join(dir, definition.id) : gemInstallDir(dir);
+    try {
+      rmSync(folder, { recursive: true, force: true });
+    } catch (e) {
+      throw new Error(`Could not delete ${folder}: ${(e as Error).message}`);
+    }
+    return;
+  }
+
   if (plan.with === "go") {
     const binary = installedBinaryPath(definition, dir);
     if (!binary || !existsSync(binary)) {

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

@@ -17,6 +17,7 @@
 import { stat } from "node:fs/promises";
 import path from "node:path";
 import { resolveBunPath } from "../autostart-generator.ts";
+import { createLogger } from "../logger.ts";
 import { canInstall, lspInstallDir, rustupServerPath } from "./lsp-install.ts";
 import { LspSession, type LspSessionState } from "./lsp-session.ts";
 import {
@@ -26,12 +27,15 @@ import {
   candidateCommandPaths,
   installedBinaryPath,
   installedServerEntry,
+  installedServerEnv,
   lspLanguageForPath,
   serversSharingInstall,
   type LanguageServerDefinition,
   type LanguageServerInstall,
 } from "./server-registry.ts";
 
+const log = createLogger("lsp");
+
 /** How long a session with no subscribers is kept before being shut down. */
 const IDLE_GRACE_MS = 5 * 60 * 1000;
 
@@ -64,7 +68,7 @@ export interface LspUnavailable {
     installHint: string;
     installable: boolean;
     /** What the button would use, so the editor can say what pressing it does. */
-    installWith?: "bun" | "go" | "rustup";
+    installWith?: LanguageServerInstall["with"];
   };
   message: string;
 }
@@ -205,7 +209,7 @@ export class LspManager {
 
       this.claim(key);
       try {
-        const session = await this.startOrReuse(key, definition, resolved.command, rootPath);
+        const session = await this.startOrReuse(key, definition, resolved, 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)) {
@@ -239,7 +243,7 @@ export class LspManager {
   private async startOrReuse(
     key: string,
     definition: LanguageServerDefinition,
-    command: string[],
+    { command, env }: { command: string[]; env?: Record<string, string> },
     rootPath: string,
   ): Promise<LspSession> {
     const existing = this.entries.get(key);
@@ -262,6 +266,7 @@ export class LspManager {
     const promise = LspSession.start({
       definition,
       command,
+      env,
       rootPath,
       onNotification: (method, params) => {
         for (const listener of this.notificationListeners) listener(key, method, params);
@@ -285,6 +290,13 @@ export class LspManager {
         this.entries.set(key, { session, subscribers: new Set(), idleTimer: null, lastUsed: ++this.useCounter });
         return session;
       })
+      .catch((e: unknown) => {
+        // Here rather than in `acquire`: every tab waiting on this start gets the same rejection,
+        // and a reconnect re-opens all of them at once. The message can carry the server's stderr.
+        const message = (e instanceof Error ? e.message : String(e)).replace(/\s+/g, " ").slice(0, 400);
+        log.error(`failed to start ${definition.id} root=${rootPath}: ${message}`);
+        throw e;
+      })
       .finally(() => this.starting.delete(key));
 
     this.starting.set(key, promise);
@@ -310,6 +322,7 @@ export class LspManager {
       if (this.entries.size <= this.maxSessions) return;
       if (entry.idleTimer) clearTimeout(entry.idleTimer);
       this.entries.delete(key);
+      log.info(`stopping ${entry.session.definition.id} root=${entry.session.rootPath}: session cap ${this.maxSessions} reached (${this.entries.size} running)`);
       void entry.session.dispose();
     }
   }
@@ -365,6 +378,10 @@ export class LspManager {
       const current = this.entries.get(key);
       if (!current || current.subscribers.size > 0) return;
       this.entries.delete(key);
+      log.info(
+        `stopping ${current.session.definition.id} root=${current.session.rootPath}: ` +
+        `idle ${Math.round(this.idleGraceMs / 1000)}s (${this.entries.size} running)`,
+      );
       void current.session.dispose();
     }, this.idleGraceMs);
     // A pending reap must not hold the process open at shutdown.
@@ -390,7 +407,7 @@ export class LspManager {
   private async resolveCommand(
     definition: LanguageServerDefinition,
     dirs: string[],
-  ): Promise<{ command: string[]; origin: ServerOrigin } | null> {
+  ): Promise<{ command: string[]; origin: ServerOrigin; env?: Record<string, string> } | null> {
     const candidates = candidateCommandPaths(definition.command, dirs);
     for (const candidate of candidates.slice(0, -1)) {
       if (await exists(candidate)) return { command: [candidate], origin: "project" };
@@ -409,10 +426,12 @@ export class LspManager {
     const onPath = Bun.which(definition.command);
     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.
+    // What the Install button put in PPM's own directory as a real binary — built with the
+    // host's Go, unpacked from a release, or a gem's binstub — spawned as itself.
     const binary = installedBinaryPath(definition, this.installDir());
-    if (binary && (await exists(binary))) return { command: [binary], origin: "ppm" };
+    if (binary && (await exists(binary))) {
+      return { command: [binary], origin: "ppm", env: installedServerEnv(definition, this.installDir()) };
+    }
 
     // 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 —
@@ -529,6 +548,7 @@ export class LspManager {
     for (const [key, entry] of doomed) {
       if (entry.idleTimer) clearTimeout(entry.idleTimer);
       this.entries.delete(key);
+      log.info(`stopping ${serverId} root=${entry.session.rootPath}: uninstalling it`);
     }
     await Promise.all(doomed.map(([, entry]) => entry.session.dispose()));
   }
@@ -542,6 +562,10 @@ export class LspManager {
    */
   killAllSync(): void {
     this.disposed = true;
+    if (this.entries.size > 0) {
+      const ids = [...this.entries.values()].map((entry) => entry.session.definition.id);
+      log.info(`killing ${ids.length} language server(s) at shutdown: ${ids.join(", ")}`);
+    }
     for (const entry of this.entries.values()) {
       if (entry.idleTimer) clearTimeout(entry.idleTimer);
       try {

package/src/services/lsp/lsp-release-catalog.ts

@@ -0,0 +1,87 @@
+/**
+ * The release builds the Install button downloads, for servers that ship one self-contained
+ * binary and no npm package: clangd and lua-language-server. Before these, both meant a system
+ * package manager — a password and a choice PPM has no business making — so they had a command to
+ * copy and no button.
+ *
+ * Pure data, keyed `<platform>-<arch>` in Node's own vocabulary so a caller passes
+ * `process.platform` and `process.arch` straight through. Every entry is pinned by version AND by
+ * SHA-256 (each matches the `digest` GitHub lists for the asset), because this puts an executable
+ * on the user's machine. A host with no row has no Install button rather than a binary for some
+ * other architecture that fails at spawn with nothing saying why.
+ */
+import type { ReleaseAsset } from "./server-registry.ts";
+
+export const CLANGD_VERSION = "23.1.0";
+const CLANGD_BASE = `https://github.com/clangd/clangd/releases/download/${CLANGD_VERSION}`;
+const CLANGD_DIR = `clangd_${CLANGD_VERSION}`;
+
+/**
+ * The archive is the binary plus `lib/clang/<n>/include`, the compiler's own headers, which
+ * clangd finds relative to itself — so the whole folder is kept, not just `bin/clangd`. Linux is
+ * x86-64 only upstream; the macOS build is universal (x86_64 + arm64, read from its Mach-O
+ * header), so both Mac rows are one file.
+ */
+export const CLANGD_ASSETS: Record<string, ReleaseAsset> = {
+  "linux-x64": {
+    url: `${CLANGD_BASE}/clangd-linux-${CLANGD_VERSION}.zip`,
+    sha256: "e53b1a96196095faedb7642cf64964f7fb9ad4a0c1f00dd2c172a3d9dcbafdfd",
+    archive: "zip",
+    binary: `${CLANGD_DIR}/bin/clangd`,
+  },
+  "darwin-x64": {
+    url: `${CLANGD_BASE}/clangd-mac-${CLANGD_VERSION}.zip`,
+    sha256: "1082e6638223b785ca2daf0939f13afcd0bb95c84ee9a4bbaff4745365159253",
+    archive: "zip",
+    binary: `${CLANGD_DIR}/bin/clangd`,
+  },
+  "darwin-arm64": {
+    url: `${CLANGD_BASE}/clangd-mac-${CLANGD_VERSION}.zip`,
+    sha256: "1082e6638223b785ca2daf0939f13afcd0bb95c84ee9a4bbaff4745365159253",
+    archive: "zip",
+    binary: `${CLANGD_DIR}/bin/clangd`,
+  },
+  "win32-x64": {
+    url: `${CLANGD_BASE}/clangd-windows-${CLANGD_VERSION}.zip`,
+    sha256: "23412a240756a162e7b98a282f36aa2a23a88db5ce16a0cbc4fef7253768c810",
+    archive: "zip",
+    binary: `${CLANGD_DIR}/bin/clangd.exe`,
+  },
+};
+
+export const LUA_LS_VERSION = "3.19.1";
+const LUA_LS_BASE = `https://github.com/LuaLS/lua-language-server/releases/download/${LUA_LS_VERSION}`;
+
+/** The archive has no top folder; the binary loads `main.lua` and `script/` from beside `bin/`. */
+export const LUA_LS_ASSETS: Record<string, ReleaseAsset> = {
+  "linux-x64": {
+    url: `${LUA_LS_BASE}/lua-language-server-${LUA_LS_VERSION}-linux-x64.tar.gz`,
+    sha256: "e9235d2d72ef55bc41cf8c99cda2ed64777682024b4bb81f5dea425060c5cbb8",
+    archive: "tar.gz",
+    binary: "bin/lua-language-server",
+  },
+  "linux-arm64": {
+    url: `${LUA_LS_BASE}/lua-language-server-${LUA_LS_VERSION}-linux-arm64.tar.gz`,
+    sha256: "abd2572e8fc929dc838a81ffb8473c5bce0bf39bfe8edb4b120b3b623176ce83",
+    archive: "tar.gz",
+    binary: "bin/lua-language-server",
+  },
+  "darwin-x64": {
+    url: `${LUA_LS_BASE}/lua-language-server-${LUA_LS_VERSION}-darwin-x64.tar.gz`,
+    sha256: "eb373c159cbe556711d7cd316315de2dce969bfd54b31edb7eb9cab2937f2cca",
+    archive: "tar.gz",
+    binary: "bin/lua-language-server",
+  },
+  "darwin-arm64": {
+    url: `${LUA_LS_BASE}/lua-language-server-${LUA_LS_VERSION}-darwin-arm64.tar.gz`,
+    sha256: "0bc077f4447f076b4c92c14e9fd303f5b569eda2ec74b4dca2b55f75fae2e90c",
+    archive: "tar.gz",
+    binary: "bin/lua-language-server",
+  },
+  "win32-x64": {
+    url: `${LUA_LS_BASE}/lua-language-server-${LUA_LS_VERSION}-win32-x64.zip`,
+    sha256: "fdb9a59108cf62517813c97fa5549b0e16d1ef0688306bac728b08434db7e4cd",
+    archive: "zip",
+    binary: "bin/lua-language-server.exe",
+  },
+};

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

@@ -25,6 +25,9 @@ import { LspMessageDecoder, encodeMessage, type JsonRpcMessage } from "./lsp-pro
 import type { LanguageServerDefinition } from "./server-registry.ts";
 import { pathToFileUri } from "../../shared/lsp-uri.ts";
 import { killProcessTree } from "../windows-process-tree.ts";
+import { createLogger } from "../logger.ts";
+
+const log = createLogger("lsp");
 
 /**
  * `stopping` is the polite handshake in `dispose()` and nothing else. It is a state rather
@@ -56,6 +59,8 @@ export interface LspSessionOptions {
   command: string[];
   /** Directory the server is rooted at; becomes its rootUri. */
   rootPath: string;
+  /** Variables laid over PPM's own environment for this server (a gem copy's `GEM_PATH`). */
+  env?: Record<string, string>;
   /** Server-initiated notifications (diagnostics, progress, logs). */
   onNotification?: (method: string, params: unknown) => void;
   /** Server-initiated requests this session does not answer itself. */
@@ -126,13 +131,18 @@ export class LspSession {
   /** Spawn the server and complete the initialize handshake. */
   static async start(options: LspSessionOptions): Promise<LspSession> {
     const session = new LspSession(options);
+    const startedAt = performance.now();
     await session.spawn();
     await session.initialize();
+    log.info(
+      `${options.definition.id} ready pid=${session.proc?.pid} root=${options.rootPath} ` +
+      `cmd=${options.command.join(" ")} init=${Math.round(performance.now() - startedAt)}ms`,
+    );
     return session;
   }
 
   private async spawn(): Promise<void> {
-    const { definition, command, rootPath } = this.options;
+    const { definition, command, rootPath, env } = this.options;
     try {
       this.proc = Bun.spawn([...command, ...definition.args], {
         cwd: rootPath,
@@ -141,7 +151,7 @@ export class LspSession {
         stderr: "pipe",
         // The server inherits the environment so it can find its own toolchain
         // (a Go module cache, a rustup shim, a project-local node).
-        env: process.env,
+        env: env ? { ...process.env, ...env } : process.env,
       });
     } catch (e) {
       throw new Error(
@@ -193,11 +203,23 @@ export class LspSession {
 
   private async watchExit(): Promise<void> {
     const code = (await this.proc?.exited) ?? null;
+    const before = this.state;
     // An exit during `dispose()`'s handshake is that handshake working, and it races the
     // assignment at the end of `dispose()` — so settle it here rather than reporting whichever
     // won as the session's final state.
     if (this.state === "stopping") this.state = "stopped";
     else if (this.state !== "stopped") this.state = "crashed";
+    const who = `${this.definition.id} pid=${this.proc?.pid}`;
+    const how = `(exit ${code}${this.proc?.signalCode ? ` ${this.proc.signalCode}` : ""})`;
+    if (this.state === "stopped") log.info(`${who} stopped ${how}`);
+    else if (before === "ready") {
+      // The tail, not the last line: Node and Bun end a crash with their own version banner.
+      const tail = this.stderrTail.replace(/\s+/g, " ").trim().slice(-300);
+      log.error(`${who} crashed ${how} root=${this.rootPath}${tail ? `: ${tail}` : ""}`);
+    }
+    // `fail()` killed it and said why, or it died starting up — which rejects `initialize`, and
+    // whoever started the session reports that, stderr included.
+    else log.debug(`${who} exited ${how} while ${before}`);
     this.rejectAllPending(
       new Error(
         `${this.definition.displayName} exited (code ${code}).` +
@@ -389,6 +411,11 @@ export class LspSession {
 
   private fail(reason: string): void {
     if (this.state === "stopped" || this.state === "stopping") return;
+    // Not when `watchExit` already reported the exit as a crash. And without the quoted output
+    // the decoder appends: after a desync that is part of a response body — a file's contents.
+    if (this.state !== "crashed") {
+      log.error(`${this.definition.id} pid=${this.proc?.pid} session failed: ${reason.replace(/:\s*".*$/s, "")}; killed`);
+    }
     this.state = "crashed";
     this.rejectAllPending(new Error(`${this.definition.displayName} session failed: ${reason}`));
     this.killProcess();