@hienlh/ppm 0.23.6 → 0.23.8

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()));
   }
 
   /**

package/src/services/lsp/server-registry.ts

@@ -32,6 +32,14 @@ export interface LanguageServerDefinition {
   rootMarkers: string[];
   /** Shown verbatim when the command cannot be found. */
   installHint: string;
+  /**
+   * How the Install button installs this server, when PPM can install it at all.
+   *
+   * Unset for a server that needs a system package manager — `clangd`, `lua-language-server`
+   * and `solargraph` mean pacman, apt, brew or a gem, i.e. a password and a choice PPM has no
+   * business making. Those keep a command to copy and no button.
+   */
+  install?: LanguageServerInstall;
   /**
    * The npm package PPM depends on for this server, when it ships one.
    *
@@ -42,6 +50,25 @@ export interface LanguageServerDefinition {
   initializationOptions?: Record<string, unknown>;
 }
 
+/**
+ * What the Install button runs.
+ *
+ * `bun` and `go` both put the server inside PPM's own directory, so nothing the user installed
+ * is touched and `rm -rf` is the uninstall. `rustup` is the exception and has to be: a
+ * rust-analyzer belongs to a toolchain, and a private copy would be the wrong one as soon as a
+ * project pins a different toolchain.
+ *
+ * PPM never installs the *toolchain*. `go` and `rustup` are offered only where the host
+ * already has them — see `canInstall` in `lsp-install.ts`.
+ */
+export type LanguageServerInstall =
+  /** `bun add <packages>`; the first package provides `command`, the rest are what it needs. */
+  | { with: "bun"; packages: string[] }
+  /** `go install <module>` with `GOBIN` pointed at PPM's own bin directory. */
+  | { with: "go"; module: string }
+  /** `rustup component add <component>`, in whichever toolchain the project selects. */
+  | { with: "rustup"; component: string };
+
 /**
  * File extension to LSP language id.
  *
@@ -110,6 +137,7 @@ export const LANGUAGE_SERVERS: LanguageServerDefinition[] = [
     // start against it with "provides no tsserver" — which reads like a broken
     // install rather than the wrong major version.
     installHint: "bun add -g typescript-language-server typescript@5",
+    install: { with: "bun", packages: ["typescript-language-server", "typescript@5"] },
     // Shipped with PPM, so this one works on a fresh install with nothing else done. The
     // project's own copy still wins where there is one — a repository pinned to TypeScript 4
     // has to be analysed by its own server, not by whatever PPM happens to carry.
@@ -153,6 +181,7 @@ export const LANGUAGE_SERVERS: LanguageServerDefinition[] = [
     args: ["--stdio"],
     rootMarkers: ["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt", "Pipfile"],
     installHint: "bun add -g pyright",
+    install: { with: "bun", packages: ["pyright"] },
   },
   {
     id: "gopls",
@@ -162,6 +191,9 @@ export const LANGUAGE_SERVERS: LanguageServerDefinition[] = [
     args: [],
     rootMarkers: ["go.work", "go.mod"],
     installHint: "go install golang.org/x/tools/gopls@latest",
+    // Built by the host's own Go, into PPM's directory: `GOBIN` is what decides where the
+    // binary lands, so `~/go/bin` is left exactly as the user arranged it. 10.6 s here.
+    install: { with: "go", module: "golang.org/x/tools/gopls@latest" },
   },
   {
     id: "rust-analyzer",
@@ -171,6 +203,11 @@ export const LANGUAGE_SERVERS: LanguageServerDefinition[] = [
     args: [],
     rootMarkers: ["Cargo.toml"],
     installHint: "rustup component add rust-analyzer",
+    // The one server PPM does not keep in its own directory: rust-analyzer belongs to a
+    // *toolchain*, and a copy of its own would be the wrong one the moment a project pins a
+    // different one. `rustup which` is then both the lookup and the installed-check — it exits
+    // non-zero with "unknown binary" when the component is absent, in 3 ms.
+    install: { with: "rustup", component: "rust-analyzer" },
   },
   {
     id: "clangd",
@@ -189,6 +226,7 @@ export const LANGUAGE_SERVERS: LanguageServerDefinition[] = [
     args: ["--stdio"],
     rootMarkers: ["package.json"],
     installHint: "bun add -g vscode-langservers-extracted",
+    install: { with: "bun", packages: ["vscode-langservers-extracted"] },
   },
   {
     id: "html",
@@ -198,6 +236,7 @@ export const LANGUAGE_SERVERS: LanguageServerDefinition[] = [
     args: ["--stdio"],
     rootMarkers: ["package.json"],
     installHint: "bun add -g vscode-langservers-extracted",
+    install: { with: "bun", packages: ["vscode-langservers-extracted"] },
   },
   {
     id: "css",
@@ -207,6 +246,7 @@ export const LANGUAGE_SERVERS: LanguageServerDefinition[] = [
     args: ["--stdio"],
     rootMarkers: ["package.json"],
     installHint: "bun add -g vscode-langservers-extracted",
+    install: { with: "bun", packages: ["vscode-langservers-extracted"] },
   },
   {
     id: "yaml",
@@ -216,6 +256,7 @@ export const LANGUAGE_SERVERS: LanguageServerDefinition[] = [
     args: ["--stdio"],
     rootMarkers: [],
     installHint: "bun add -g yaml-language-server",
+    install: { with: "bun", packages: ["yaml-language-server"] },
   },
   {
     id: "bash",
@@ -225,6 +266,7 @@ export const LANGUAGE_SERVERS: LanguageServerDefinition[] = [
     args: ["start"],
     rootMarkers: [],
     installHint: "bun add -g bash-language-server",
+    install: { with: "bun", packages: ["bash-language-server"] },
   },
   {
     id: "intelephense",
@@ -234,6 +276,7 @@ export const LANGUAGE_SERVERS: LanguageServerDefinition[] = [
     args: ["--stdio"],
     rootMarkers: ["composer.json"],
     installHint: "bun add -g intelephense",
+    install: { with: "bun", packages: ["intelephense"] },
   },
   {
     id: "solargraph",
@@ -261,6 +304,7 @@ export const LANGUAGE_SERVERS: LanguageServerDefinition[] = [
     args: ["--stdio"],
     rootMarkers: ["package.json"],
     installHint: "bun add -g @vue/language-server",
+    install: { with: "bun", packages: ["@vue/language-server"] },
   },
   {
     id: "svelte",
@@ -270,6 +314,7 @@ export const LANGUAGE_SERVERS: LanguageServerDefinition[] = [
     args: ["--stdio"],
     rootMarkers: ["package.json"],
     installHint: "bun add -g svelte-language-server",
+    install: { with: "bun", packages: ["svelte-language-server"] },
   },
 ];
 
@@ -282,6 +327,26 @@ export function serverById(id: string): LanguageServerDefinition | undefined {
   return LANGUAGE_SERVERS.find((s) => s.id === id);
 }
 
+/**
+ * The other servers that an uninstall of this one would also take away.
+ *
+ * One npm package can provide several servers — `vscode-langservers-extracted` is JSON, HTML
+ * and CSS at once — so `bun remove` of it removes all three whichever row the button was on.
+ * That is not a thing to discover afterwards, so the Settings pane names them before asking.
+ * Nothing shares a `go` module or a rustup component, so those answer with nothing.
+ */
+export function serversSharingInstall(definition: LanguageServerDefinition): LanguageServerDefinition[] {
+  const plan = definition.install;
+  if (plan?.with !== "bun") return [];
+  const pkg = packageName(plan.packages[0] ?? "");
+  return LANGUAGE_SERVERS.filter(
+    (s) =>
+      s.id !== definition.id &&
+      s.install?.with === "bun" &&
+      packageName(s.install.packages[0] ?? "") === pkg,
+  );
+}
+
 /**
  * Directories to search, nearest first, from the file's own directory up to and
  * including the project root.
@@ -386,16 +451,67 @@ export function bundledServerEntry(
 ): string | null {
   const pkg = definition.bundledPackage;
   if (!pkg) return null;
-  let manifestPath: string;
+  try {
+    return binEntry(resolve(`${pkg}/package.json`), definition.command);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The entry script of an npm server the Install button put in PPM's own directory.
+ *
+ * Built as a path *under* `installDir` rather than resolved through `require`: Node resolution
+ * climbs out of the directory it starts in, so a stray `~/node_modules` would answer for a
+ * package PPM never installed — and whatever answers here is executed.
+ */
+export function installedServerEntry(definition: LanguageServerDefinition, installDir: string): string | null {
+  if (definition.install?.with !== "bun") return null;
+  const spec = definition.install.packages[0];
+  if (!spec) return null;
+  const pkgDir = path.join(installDir, "node_modules", ...packageName(spec).split("/"));
+  return binEntry(path.join(pkgDir, "package.json"), definition.command);
+}
+
+/**
+ * Where a compiled server the Install button built would be — PPM's own `bin` directory.
+ *
+ * That is `GOBIN` for the install, so the binary is PPM's to find and to delete, and the
+ * user's `~/go/bin` is left as they arranged it. A plain path: whether it exists is the
+ * caller's `exists()`, the same as for every other candidate.
+ */
+export function installedBinaryPath(
+  definition: LanguageServerDefinition,
+  installDir: string,
+  platform: NodeJS.Platform = process.platform,
+): string | null {
+  if (definition.install?.with !== "go") return null;
+  return path.join(installDir, "bin", platform === "win32" ? `${definition.command}.exe` : definition.command);
+}
+
+/** `typescript@5` → `typescript`, keeping a scoped package's own leading `@`. */
+export function packageName(spec: string): string {
+  const at = spec.indexOf("@", 1);
+  return at === -1 ? spec : spec.slice(0, at);
+}
+
+/**
+ * `bin[command]` from a package manifest, as an absolute path.
+ *
+ * Both callers want the package's **entry script** and not npm's `.bin` shim: that shim starts
+ * `#!/usr/bin/env node`, and someone who installed PPM with bun may have no `node` on the
+ * machine at all — measured as exit **127** with `env: 'node': No such file or directory`,
+ * after the server had already been reported as installed. The manager runs the entry with bun.
+ */
+function binEntry(manifestPath: string, command: string): string | null {
   let manifest: { bin?: string | Record<string, string> };
   try {
-    manifestPath = resolve(`${pkg}/package.json`);
     manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as typeof manifest;
   } catch {
-    return null;
+    return null; // not installed, or a manifest we cannot read
   }
   // `bin` is either a bare string — the package's own name — or a map of command to path.
-  const relative = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.[definition.command];
+  const relative = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.[command];
   if (!relative) return null;
   return path.resolve(path.dirname(manifestPath), relative);
 }

package/src/services/named-tunnel/named-tunnel-config.ts

@@ -9,6 +9,8 @@
 export type TunnelMode = "quick" | "named";
 
 export interface ResolvedTunnelConfig {
+  /** Master switch — `false` means spawn no tunnel at all, whatever `mode` says. */
+  enabled: boolean;
   mode: TunnelMode;
   hostname: string | null;
   tunnelName: string | null;
@@ -18,7 +20,7 @@ export interface ResolvedTunnelConfig {
   dismissed: boolean;
 }
 
-const QUICK: Omit<ResolvedTunnelConfig, "dismissed"> = {
+const QUICK: Omit<ResolvedTunnelConfig, "dismissed" | "enabled"> = {
   mode: "quick", hostname: null, tunnelName: null, token: null, zoneID: null, accountID: null,
 };
 
@@ -35,6 +37,9 @@ export function resolveTunnelConfig(raw: unknown): ResolvedTunnelConfig {
   }
 
   const dismissed = obj != null && typeof obj.dismissed === "boolean" ? obj.dismissed : false;
+  // Absent means a row older than the master switch, back when the tunnel was
+  // unconditional — absent is therefore on, never off.
+  const enabled = obj != null && typeof obj.enabled === "boolean" ? obj.enabled : true;
 
   // Named mode requires BOTH the stored mode flag AND all four identity fields —
   // checking fields alone would resurrect a tunnel the user explicitly disabled,
@@ -46,10 +51,11 @@ export function resolveTunnelConfig(raw: unknown): ResolvedTunnelConfig {
     nonEmptyString(obj.accountID);
 
   if (!named || obj == null) {
-    return { ...QUICK, dismissed };
+    return { ...QUICK, enabled, dismissed };
   }
 
   return {
+    enabled,
     mode: "named",
     hostname: obj.namedTunnelHostname as string,
     tunnelName: nonEmptyString(obj.namedTunnelName) ? obj.namedTunnelName : null,

package/src/services/named-tunnel/named-tunnel-setup.service.ts

@@ -159,6 +159,10 @@ async function runSetupInner(hostname: string): Promise<SetupOutcome> {
 
   broadcastGlobalEvent({ type: "tunnel:setup_step", step: "apply", message: "applying configuration" });
   configService.set("tunnel", {
+    // Carry the master switch across rather than defaulting it: configuring a
+    // domain is not consent to start sharing, and this write would otherwise
+    // silently turn a deliberately-off tunnel back on.
+    enabled: configService.get("tunnel").enabled,
     mode: "named",
     namedTunnelName: tunnelName,
     namedTunnelHostname: hostname,

package/src/services/read-lines.ts

@@ -0,0 +1,54 @@
+/**
+ * Streaming line reader for the JSONL transcripts.
+ *
+ * Its own module because two readers need it — the full message parser and the
+ * compaction scan — and having the second import it from the first would make the
+ * two files a cycle.
+ */
+
+/**
+ * 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.
+ *
+ * `fromByte` reads a tail window instead of the whole file, for the callers that
+ * have to bound what they parse. See `fullParseWindow` in
+ * `jsonl-transcript-parser.ts` for why a bound is a window rather than a refusal.
+ */
+export 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;
+}

package/src/services/slash-items-for-provider.ts

@@ -0,0 +1,42 @@
+import { providerRegistry } from "../providers/registry.ts";
+import { listSlashItems } from "./slash-items.service.ts";
+import type { SlashItem } from "./slash-discovery/types.ts";
+import { ensureSdkCommands } from "./slash-discovery/sdk-commands.ts";
+
+/**
+ * Slash items a session can actually run.
+ *
+ * A provider that owns its own skill runtime answers for itself, and the disk-discovered
+ * Claude-side list is not merged in: a codex turn cannot execute a Claude skill, and a Claude
+ * turn cannot execute a codex one, so a combined list would offer entries that quietly do
+ * nothing when picked.
+ *
+ * PPM's host-level built-ins ARE kept, because they are intercepted before any provider runs
+ * and therefore work in every tab. Dropping them would have cost a codex tab `/clear`,
+ * `/skills`, and `/version` — commands that do work — which is a different thing from hiding
+ * ones that don't.
+ *
+ * When such a provider reports no skills — app-server failed to spawn, account not logged
+ * in — only the built-ins remain, rather than falling back to the Claude list; showing
+ * runnable-looking Claude entries in a codex tab is the very confusion this split exists to
+ * remove.
+ *
+ * Shared between `GET /chat/slash-items` and `POST /chat/prepare` so a brand-new tab (which
+ * has no session yet) and a reload of the same list agree on exactly what a provider offers.
+ */
+export async function listSlashItemsForProvider(
+  projectPath: string,
+  providerId: string | undefined,
+  sessionId: string | undefined,
+): Promise<SlashItem[]> {
+  const provider = providerId ? providerRegistry.get(providerId) : null;
+  if (provider?.listSkills) {
+    const { codexSkillsToSlashItems } = await import("./slash-discovery/codex-skill-items.ts");
+    const { getHostBuiltinSlashItems } = await import("./slash-discovery/builtin-commands.ts");
+    return [...codexSkillsToSlashItems(await provider.listSkills(sessionId)), ...getHostBuiltinSlashItems()];
+  }
+  // Claude's own built-ins need a live SDK session to enumerate; cached 30 min,
+  // so only the first request per project pays for the CLI spawn.
+  await ensureSdkCommands(projectPath);
+  return listSlashItems(projectPath);
+}