@herbertgao/pi-extensions 2026.8.4 → 2026.8.6

package/node_modules/pi-lens/dist/clients/lsp/launch.js

@@ -12,8 +12,11 @@ import os from "node:os";
 import path from "node:path";
 import { isTestMode } from "../env-utils.js";
 import { getGlobalPiLensDir } from "../file-utils.js";
+import { isFullyQualified } from "../path-utils.js";
 import { findGlobalBinary } from "../package-manager.js";
 import { redactSecrets } from "../redact/secrets.js";
+import { classifySpawnFailure, SpawnFailureError, } from "../safe-spawn.js";
+import { getRubyVersionDirNamesAsync } from "./ruby-drive-dirs.js";
 const isWindows = process.platform === "win32";
 /**
  * Whether a resolved command must be spawned through a shell on Windows.
@@ -109,7 +112,7 @@ function getLiveWindowsPath() {
     }
     return _liveWindowsPath;
 }
-function buildAugmentedPath(basePath) {
+async function buildAugmentedPath(basePath) {
     const candidates = [];
     const nodeDir = path.dirname(process.execPath);
     if (nodeDir) {
@@ -125,16 +128,12 @@ function buildAugmentedPath(basePath) {
         candidates.push(PI_LENS_TOOLS_BIN_DIR);
         candidates.push(path.join(driveRoot, "Program Files", "Go", "bin"));
         candidates.push(path.join(driveRoot, "Go", "bin"));
-        // Ruby installer drops versioned dirs (e.g. Ruby34-x64) on the drive root — scan dynamically
-        try {
-            for (const entry of fs.readdirSync(driveRoot)) {
-                if (/^ruby\d/i.test(entry)) {
-                    candidates.push(path.join(driveRoot, entry, "bin"));
-                }
-            }
-        }
-        catch {
-            // drive root not readable — skip
+        // Ruby installer drops versioned dirs (e.g. Ruby34-x64) on the drive root.
+        // Read off the event loop and memoized once per process (#1137): a
+        // synchronous drive-root enumeration on every LSP spawn blocked the loop
+        // for the whole stall on a slow cloud/network-backed drive root.
+        for (const entry of await getRubyVersionDirNamesAsync(driveRoot)) {
+            candidates.push(path.join(driveRoot, entry, "bin"));
         }
     }
     // On Windows, merge the live registry PATH so newly installed tools are visible
@@ -339,10 +338,12 @@ function _attachErrorHandler(proc, context, logContext, rejectOnImmediateError)
                 err.message +
                 (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""));
         }
-        // If we have a reject function and this is an immediate spawn error, reject
-        if (rejectOnImmediateError &&
-            err.code === "ENOENT") {
-            rejectOnImmediateError(err);
+        // Preserve intent at the boundary instead of leaking a raw errno check.
+        if (rejectOnImmediateError && logContext) {
+            void classifySpawnFailure(err, {
+                command: logContext.command,
+                cwd: logContext.cwd,
+            }).then(rejectOnImmediateError);
         }
     });
     proc.on("close", (code, signal) => {
@@ -402,7 +403,7 @@ function _attachErrorHandler(proc, context, logContext, rejectOnImmediateError)
 export async function launchLSP(command, args = [], options = {}) {
     const cwd = String(options.cwd ?? process.cwd());
     const mergedEnv = { ...process.env, ...options.env };
-    const augmentedPath = buildAugmentedPath(resolvePathValue(mergedEnv));
+    const augmentedPath = await buildAugmentedPath(resolvePathValue(mergedEnv));
     const env = {
         ...mergedEnv,
         PATH: augmentedPath,
@@ -412,10 +413,10 @@ export async function launchLSP(command, args = [], options = {}) {
     // - If already absolute, use as-is
     // - If it's a simple command (no path separators), let system find it via PATH
     // - Otherwise, resolve relative to cwd
-    const isRelativePath = !path.isAbsolute(command) &&
+    const isRelativePath = !isFullyQualified(command) &&
         (command.includes(path.sep) || command.includes("/"));
     const explicitCommand = isRelativePath ? path.resolve(cwd, command) : command;
-    const resolvedCommand = !path.isAbsolute(command) &&
+    const resolvedCommand = !isFullyQualified(command) &&
         !command.includes(path.sep) &&
         !command.includes("/")
         ? (findBinaryOnPath(command, env) ?? explicitCommand)
@@ -428,7 +429,7 @@ export async function launchLSP(command, args = [], options = {}) {
     // If command not found, try npm global as fallback (handles PATH caching after install)
     let spawnCommand = resolvedCommand;
     // First, try to find in npm global if it's a simple command name
-    if (!path.isAbsolute(command) &&
+    if (!isFullyQualified(command) &&
         !command.includes(path.sep) &&
         !command.includes("/")) {
         const globalBinPath = await findGlobalBinary(command);
@@ -444,7 +445,8 @@ export async function launchLSP(command, args = [], options = {}) {
         /\.(cmd|bat)$/i.test(spawnCommand) &&
         !isCmdShimValid(spawnCommand)) {
         logSessionStart(`lsp cmd-shim-invalid: ${spawnCommand} target missing — skipping candidate`);
-        throw new Error(`LSP .cmd shim target not found: ${spawnCommand}. The npm package may not be installed.`);
+        const cause = Object.assign(new Error(`LSP .cmd shim target not found: ${spawnCommand}`), { code: "ENOENT" });
+        throw await classifySpawnFailure(cause, { command, cwd });
     }
     // P0 FIX: Never spawn .ps1 wrappers on Windows — they hang when PowerShell
     // execution policy is Restricted/AllSigned. Prefer .cmd or direct node.
@@ -466,7 +468,7 @@ export async function launchLSP(command, args = [], options = {}) {
     }
     catch (err) {
         // If spawn failed with simple command, try npm global
-        if (!path.isAbsolute(command) &&
+        if (!isFullyQualified(command) &&
             !command.includes(path.sep) &&
             !command.includes("/")) {
             const globalBinPath = await findGlobalBinary(command);
@@ -476,11 +478,11 @@ export async function launchLSP(command, args = [], options = {}) {
                 proc = trySpawn(globalBinPath, args, cwd, env, needsShellGlobal);
             }
             else {
-                throw err;
+                throw await classifySpawnFailure(err, { command, cwd });
             }
         }
         else {
-            throw err;
+            throw await classifySpawnFailure(err, { command, cwd });
         }
     }
     if (!proc.stdin || !proc.stdout || !proc.stderr) {
@@ -512,10 +514,14 @@ export async function launchLSP(command, args = [], options = {}) {
             let settled = false;
             // Attach error handler that can reject for immediate errors
             proc.on("error", (err) => {
-                if (!settled && (err.code === "ENOENT" || err.code === "EINVAL")) {
+                if (!settled) {
                     settled = true;
-                    reject(new Error(`LSP server binary not found: ${command}. ` +
-                        `Install it or check your PATH.${formatStartupStderr(startupStderr)}`));
+                    void classifySpawnFailure(err, { command, cwd }).then((failure) => {
+                        const detail = formatStartupStderr(startupStderr);
+                        reject(detail
+                            ? new SpawnFailureError(failure.kind, `${failure.message}${detail}`, failure.cause)
+                            : failure);
+                    });
                 }
             });
             // Also listen for immediate exit

package/node_modules/pi-lens/dist/clients/lsp/path-utils.js

@@ -2,4 +2,4 @@
  * Re-export from shared path-utils.
  * Kept as a local module for LSP imports that use relative paths.
  */
-export { isUnderDir, normalizeFilePath, normalizeMapKey, pathsEqual, pathToUri, uriToPath, } from "../path-utils.js";
+export { isUnderDir, normalizeFilePath, normalizeEphemeralMapKey, normalizeMapKey, pathsEqual, pathToUri, uriToDiskPath, uriToPath, } from "../path-utils.js";

package/node_modules/pi-lens/dist/clients/lsp/ruby-drive-dirs.js

@@ -0,0 +1,83 @@
+/**
+ * Windows Ruby-installer drive-root version-dir discovery (refs #1137).
+ *
+ * The Ruby installer drops versioned directories (e.g. `Ruby34-x64`) directly
+ * at a drive root, and the drive and version suffix vary — so both the LSP
+ * candidate builder (`rubyBinCandidates`) and the spawn PATH augmenter
+ * (`buildAugmentedPath`) scan the drive root for `ruby<N>...` directories.
+ *
+ * Enumerating a drive root **synchronously on every LSP spawn** was a genuine
+ * #1137 event-loop offender: a stalled cloud/network-backed drive-root
+ * `readdirSync` blocks the Node loop (and pi's TUI) for the entire stall. This
+ * module makes that enumeration:
+ *   1. **O(1) amortized** — the matching directory names are memoized for the
+ *      process (the set is static for a session; the previous inline code
+ *      equally required a restart to notice a new Ruby install on PATH), and
+ *   2. **non-blocking on the hot path** — `buildAugmentedPath` (called on every
+ *      spawn) reads the drive root via `fs.promises.readdir` off the loop.
+ *
+ * Both readers share ONE cache keyed by `driveRoot`, so at most one drive-root
+ * read happens per drive per process regardless of which reader runs first.
+ * Callers derive their own paths from the returned directory NAMES (the two
+ * readers build different suffixes: `bin/<tool>` vs `bin`), so only the raw
+ * `ruby<N>` names are cached.
+ */
+import { BoundedLruCache } from "../bounded-cache.js";
+import { normalizeMapKey } from "../path-utils.js";
+import * as fs from "node:fs";
+/** Matches the Ruby installer's `Ruby34-x64`, `ruby3.3`, … drive-root dirs. */
+const RUBY_VERSION_DIR = /^ruby\d/i;
+/** Process-lifetime memo of matching dir names, keyed by drive root (e.g. `C:\`). */
+const rubyDirNamesCache = new BoundedLruCache(16);
+function rubyDriveKey(driveRoot) {
+    return normalizeMapKey(driveRoot);
+}
+function filterRubyDirNames(entries) {
+    return entries.filter((name) => RUBY_VERSION_DIR.test(name));
+}
+/**
+ * Memoized **synchronous** enumeration for sync callers (`rubyBinCandidates`).
+ * First call reads the drive root once (fail-open to `[]` on an unreadable
+ * root); every later call is a cache hit. If an async caller populated the
+ * cache first, this returns that result with no drive-root read at all.
+ */
+export function getRubyVersionDirNamesSync(driveRoot) {
+    const key = rubyDriveKey(driveRoot);
+    const cached = rubyDirNamesCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    let names;
+    try {
+        names = filterRubyDirNames(fs.readdirSync(driveRoot));
+    }
+    catch {
+        names = [];
+    }
+    rubyDirNamesCache.set(key, names);
+    return names;
+}
+/**
+ * Memoized **async** twin for the hot spawn path (`buildAugmentedPath`) — reads
+ * the drive root via `fs.promises.readdir` so a slow/stalled cloud-backed drive
+ * root never blocks the event loop. Shares the same process cache as the sync
+ * reader (identical content, so a benign sync/async populate race is fine).
+ */
+export async function getRubyVersionDirNamesAsync(driveRoot) {
+    const key = rubyDriveKey(driveRoot);
+    const cached = rubyDirNamesCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    let names;
+    try {
+        names = filterRubyDirNames(await fs.promises.readdir(driveRoot));
+    }
+    catch {
+        names = [];
+    }
+    rubyDirNamesCache.set(key, names);
+    return names;
+}
+/** Test-only: clear the process memo so each case starts cold. */
+export function __resetRubyDriveDirsCacheForTest() {
+    rubyDirNamesCache.clear();
+}