pi-lens 3.8.62 → 3.8.64

package/dist/clients/lsp/client.js

@@ -11,6 +11,7 @@ import { spawn as nodeSpawn } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { access, readFile } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
+import { withTimeout } from "../deadline-utils.js";
 import { logLatency } from "../latency-logger.js";
 // vscode-jsonrpc v9 ships an `exports` map exposing the Node entry as the
 // `./node` subpath (no `.js`); the old `/node.js` file path no longer resolves.
@@ -76,7 +77,20 @@ export const CLIENT_CAPABILITIES = {
 const NAV_REQUEST_TIMEOUT_MS = positiveIntFromEnv("PI_LENS_LSP_NAV_REQUEST_TIMEOUT_MS", 10_000); // 10s — per-request ceiling; prevents heavy servers (vue, svelte) from hanging
 const DIAGNOSTICS_WAIT_TIMEOUT_MS = positiveIntFromEnv("PI_LENS_LSP_DIAGNOSTICS_WAIT_MS", 10_000);
 const PULL_DIAGNOSTICS_RETRY_INTERVAL_MS = positiveIntFromEnv("PI_LENS_LSP_PULL_RETRY_INTERVAL_MS", 250);
+// Per-request ceiling for pull diagnostics (textDocument/diagnostic), mirroring
+// NAV_REQUEST_TIMEOUT_MS. safeSendRequest only settles on a reply or a *destroyed*
+// stream, so a pull-mode server that is alive but hung (accepts the request, never
+// replies) would await forever — hanging clientWaitForDiagnostics and, upstream,
+// the diagnostics flush. On timeout the request is treated as `unavailable`, which
+// (per #240) is NOT read as clean and falls through to the bounded push backstop.
+const PULL_REQUEST_TIMEOUT_MS = positiveIntFromEnv("PI_LENS_LSP_PULL_REQUEST_TIMEOUT_MS", 10_000);
 const SHUTDOWN_REQUEST_TIMEOUT_MS = positiveIntFromEnv("PI_LENS_LSP_SHUTDOWN_TIMEOUT_MS", 1000);
+// Anti-deadlock backstop for workspace/executeCommand. Deliberately generous
+// (30s): the command is mutating and legitimately long-running (a real server
+// refactor / organize-imports), so this must not truncate valid work — it only
+// stops a hung server from blocking the caller forever. On timeout the command
+// may still be applying server-side; we surface that rather than pretend it ran.
+const EXECUTE_COMMAND_TIMEOUT_MS = positiveIntFromEnv("PI_LENS_LSP_EXECUTE_COMMAND_TIMEOUT_MS", 30_000);
 const LSP_CRASH_CODES = new Set([
     "ERR_STREAM_DESTROYED",
     "ERR_STREAM_WRITE_AFTER_END",
@@ -179,18 +193,36 @@ export async function killProcessTree(proc, pid, options = {}) {
         }
         return;
     }
+    const killPosixProcessGroup = (signal) => {
+        if (pid <= 0)
+            return false;
+        try {
+            process.kill(-pid, signal);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const killDirectChild = (signal) => {
+        try {
+            proc.kill(signal);
+        }
+        catch {
+            // best-effort
+        }
+    };
     try {
-        proc.kill("SIGTERM");
+        if (!killPosixProcessGroup("SIGTERM")) {
+            killDirectChild("SIGTERM");
+        }
         if (options.fast) {
             const timer = setTimeout(() => {
-                try {
-                    if (!proc.killed) {
-                        proc.kill("SIGKILL");
+                if (!proc.killed) {
+                    if (!killPosixProcessGroup("SIGKILL")) {
+                        killDirectChild("SIGKILL");
                     }
                 }
-                catch {
-                    // best-effort
-                }
             }, 1500);
             timer.unref?.();
             proc.unref?.();
@@ -199,14 +231,11 @@ export async function killProcessTree(proc, pid, options = {}) {
         // SIGTERM → 1.5s → SIGKILL escalation.
         // SIGTERM alone can leave zombie processes if the server hangs.
         await new Promise((resolve) => setTimeout(resolve, 1500));
-        try {
-            if (!proc.killed) {
-                proc.kill("SIGKILL");
+        if (!proc.killed) {
+            if (!killPosixProcessGroup("SIGKILL")) {
+                killDirectChild("SIGKILL");
             }
         }
-        catch {
-            // best-effort
-        }
     }
     catch {
         // ignore
@@ -294,6 +323,7 @@ export function applyDynamicCapabilities(state) {
         state.workspaceDiagnosticsSupport = {
             advertised: true,
             mode: "pull",
+            workspaceDiagnostics: registeredMethods.has("workspace/diagnostic"),
             diagnosticProviderKind: "dynamic",
         };
     }
@@ -303,6 +333,7 @@ export function applyDynamicCapabilities(state) {
         state.workspaceDiagnosticsSupport = {
             advertised: false,
             mode: "push-only",
+            workspaceDiagnostics: false,
             diagnosticProviderKind: "none",
         };
     }
@@ -439,12 +470,17 @@ function setupConnectionLifecycle(state) {
         }
     });
 }
-async function clientRequestPullDiagnostics(state, filePath) {
+async function clientRequestPullDiagnostics(state, filePath, budgetMs = PULL_REQUEST_TIMEOUT_MS) {
     if (!isClientAlive(state))
         return { status: "unavailable" };
     const uri = pathToFileURL(filePath).href;
     try {
-        const report = await safeSendRequest(state.connection, "textDocument/diagnostic", { textDocument: { uri } });
+        // withTimeout is the backstop against a hung pull-mode server: without it
+        // this await never settles unless the stream is destroyed. Bounded by the
+        // smaller of the absolute ceiling and the caller's remaining wait budget.
+        // On timeout the caught error yields `unavailable` below (never a false
+        // `clean`), so it falls through to the push-wait/timeout backstop.
+        const report = await withTimeout(safeSendRequest(state.connection, "textDocument/diagnostic", { textDocument: { uri } }), Math.max(1, Math.min(PULL_REQUEST_TIMEOUT_MS, budgetMs)));
         if (!report)
             return { status: "unavailable" };
         const normalizedPath = normalizeMapKey(filePath);
@@ -472,6 +508,39 @@ async function clientRequestPullDiagnostics(state, filePath) {
         return { status: "unavailable" };
     }
 }
+/**
+ * One project-wide `workspace/diagnostic` pull — a single request that returns
+ * diagnostics for every document the server knows, instead of opening N files.
+ * Returns per-file reports, or `undefined` on unsupported/dead/timeout/malformed
+ * (caller falls back to the per-file path). `unchanged`-kind items carry no
+ * diagnostics and are skipped, so a file absent from the result is "clean".
+ */
+export async function clientRequestWorkspaceDiagnostics(state, budgetMs) {
+    if (!isClientAlive(state))
+        return undefined;
+    if (!state.workspaceDiagnosticsSupport.workspaceDiagnostics)
+        return undefined;
+    try {
+        const report = await withTimeout(safeSendRequest(state.connection, "workspace/diagnostic", { previousResultIds: [] }), Math.max(1, budgetMs));
+        if (!report || !Array.isArray(report.items))
+            return undefined;
+        const out = [];
+        for (const item of report.items) {
+            // Only "full" reports carry items; "unchanged" means "same as last pull"
+            // (none, since previousResultIds is empty on this one-shot request).
+            if (!item?.uri || item.kind !== "full")
+                continue;
+            out.push({
+                filePath: uriToPath(item.uri),
+                diagnostics: normalizeLspDiagnostics(item.items ?? []),
+            });
+        }
+        return out;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function clientWaitForDiagnostics(state, filePath, timeoutMs, options = {}) {
     const normalizedPath = normalizeMapKey(filePath);
     const minVersion = options.minVersion;
@@ -499,7 +568,7 @@ export async function clientWaitForDiagnostics(state, filePath, timeoutMs, optio
         // `hasFreshDiagnostics()`, which is unconditionally true when there is no
         // version baseline (`minVersion === undefined`), so a failed pull returned
         // 0 and was read as a fresh clean.
-        let outcome = await clientRequestPullDiagnostics(state, filePath);
+        let outcome = await clientRequestPullDiagnostics(state, filePath, timeoutMs);
         if (outcome.status === "found")
             return;
         let sawClean = outcome.status === "clean";
@@ -513,7 +582,7 @@ export async function clientWaitForDiagnostics(state, filePath, timeoutMs, optio
         // any point is a valid affirmative answer for this touch.
         while (outcome.status !== "found" && Date.now() - startedAt < retryBudgetMs) {
             await new Promise((resolve) => setTimeout(resolve, PULL_DIAGNOSTICS_RETRY_INTERVAL_MS));
-            outcome = await clientRequestPullDiagnostics(state, filePath);
+            outcome = await clientRequestPullDiagnostics(state, filePath, Math.max(0, retryBudgetMs - (Date.now() - startedAt)));
             if (outcome.status === "clean")
                 sawClean = true;
         }
@@ -714,18 +783,20 @@ async function toWirePosition(state, filePath, line, character) {
 function navStaleDropEnabled() {
     return process.env.PI_LENS_LSP_NAV_STALE_DROP !== "0";
 }
-async function navRequest(state, method, params, 
+// Exported for the timeout regression tests (#365). `timeoutMs` overrides the
+// per-request ceiling so a test can bound a hung server quickly.
+export async function navRequest(state, method, params, 
 // When provided, the request is dropped if the document's version advances
 // (an edit landed) between send and response. Omit for non-single-file
 // requests (workspaceSymbol, call-hierarchy follow-ups) that have no version.
-staleCheckPath) {
+staleCheckPath, timeoutMs = NAV_REQUEST_TIMEOUT_MS) {
     if (!isClientAlive(state))
         return null;
     const normalizedPath = staleCheckPath !== undefined ? normalizeMapKey(staleCheckPath) : undefined;
     const requestVersion = normalizedPath !== undefined
         ? state.documentVersions.get(normalizedPath)
         : undefined;
-    const result = (await withTimeout(safeSendRequest(state.connection, method, params), NAV_REQUEST_TIMEOUT_MS).catch((err) => {
+    const result = (await withTimeout(safeSendRequest(state.connection, method, params), timeoutMs).catch((err) => {
         if (err instanceof Error && err.message.startsWith("Timeout after")) {
             return undefined;
         }
@@ -743,6 +814,50 @@ staleCheckPath) {
     }
     return result;
 }
+// Run an advertised server command via workspace/executeCommand, with the
+// generous EXECUTE_COMMAND_TIMEOUT_MS anti-deadlock backstop. Preserves the
+// hardening invariants: allowlist-by-advertisement (only commands the server
+// declared) and the serverEditsAllowed window that gates server-driven
+// applyEdit to the duration of an explicit call. Exported with an overridable
+// `timeoutMs` for the #365 regression tests.
+export async function runServerCommand(state, command, args, timeoutMs = EXECUTE_COMMAND_TIMEOUT_MS) {
+    if (!isClientAlive(state)) {
+        return { executed: false, reason: "lsp client not alive" };
+    }
+    if (!state.advertisedCommands.has(command)) {
+        return {
+            executed: false,
+            reason: `command "${command}" is not advertised by the ${state.serverId} server`,
+        };
+    }
+    state.serverEditsAllowed += 1;
+    try {
+        let result;
+        try {
+            result = await withTimeout(safeSendRequest(state.connection, "workspace/executeCommand", {
+                command,
+                arguments: args ?? [],
+            }), timeoutMs);
+        }
+        catch (err) {
+            // Generous backstop only: a timeout means the server is hung (or the
+            // command is running longer than the ceiling). Surface it honestly — the
+            // command may still be applying — instead of hanging the caller. Real
+            // (non-timeout) errors still propagate.
+            if (err instanceof Error && err.message.startsWith("Timeout after")) {
+                return {
+                    executed: false,
+                    reason: `workspace/executeCommand timed out after ${timeoutMs}ms — the command may still be applying server-side`,
+                };
+            }
+            throw err;
+        }
+        return { executed: true, result };
+    }
+    finally {
+        state.serverEditsAllowed -= 1;
+    }
+}
 async function resolveCodeActionBestEffort(state, action) {
     if (!isClientAlive(state) || action.edit)
         return action;
@@ -999,6 +1114,9 @@ export async function createLSPClient(options) {
         getWorkspaceDiagnosticsSupport() {
             return state.workspaceDiagnosticsSupport;
         },
+        requestWorkspaceDiagnostics(budgetMs) {
+            return clientRequestWorkspaceDiagnostics(state, budgetMs);
+        },
         getOperationSupport() {
             return state.operationSupport;
         },
@@ -1009,25 +1127,7 @@ export async function createLSPClient(options) {
             return state.rawCapabilityKeys ?? [];
         },
         async executeCommand(command, args) {
-            if (!isClientAlive(state)) {
-                return { executed: false, reason: "lsp client not alive" };
-            }
-            // Hardening: allowlist-by-advertisement. Only commands the server
-            // itself declared (static or dynamic) may run — no arbitrary strings.
-            if (!state.advertisedCommands.has(command)) {
-                return {
-                    executed: false,
-                    reason: `command "${command}" is not advertised by the ${state.serverId} server`,
-                };
-            }
-            state.serverEditsAllowed += 1;
-            try {
-                const result = await safeSendRequest(state.connection, "workspace/executeCommand", { command, arguments: args ?? [] });
-                return { executed: true, result };
-            }
-            finally {
-                state.serverEditsAllowed -= 1;
-            }
+            return runServerCommand(state, command, args);
         },
         get diagnosticsVersion() {
             return state.diagnosticsVersion;
@@ -1091,14 +1191,22 @@ export async function createLSPClient(options) {
         async workspaceSymbol(query) {
             if (!isClientAlive(state))
                 return [];
-            const result = await safeSendRequest(connection, "workspace/symbol", { query });
+            // Route through navRequest for the shared withTimeout ceiling — a hung
+            // server would otherwise await forever (safeSendRequest only settles on
+            // a reply or a destroyed stream). No staleCheckPath: not single-file.
+            const result = await navRequest(state, "workspace/symbol", {
+                query,
+            });
             return result ?? [];
         },
         async codeAction(filePath, line, character, endLine, endCharacter) {
             if (!isClientAlive(state))
                 return [];
             const uri = pathToFileURL(filePath).href;
-            const result = await safeSendRequest(connection, "textDocument/codeAction", {
+            // navRequest adds the shared withTimeout ceiling + single-file
+            // stale-drop (matches documentSymbol); a hung server no longer awaits
+            // forever, and code actions computed against superseded content drop.
+            const result = await navRequest(state, "textDocument/codeAction", {
                 textDocument: { uri },
                 range: {
                     start: await toWirePosition(state, filePath, line, character),
@@ -1107,7 +1215,7 @@ export async function createLSPClient(options) {
                 context: {
                     diagnostics: getMergedDiagnosticsForPath(state, normalizeMapKey(filePath)),
                 },
-            });
+            }, filePath);
             if (!result || !Array.isArray(result))
                 return [];
             const actions = result.filter((item) => typeof item === "object" && item !== null && "title" in item);
@@ -1222,25 +1330,6 @@ function isStreamError(err) {
         err.code === "EPIPE");
 }
 // Using shared path utilities from path-utils.ts
-async function withTimeout(promise, timeoutMs) {
-    let timeout;
-    // Suppress unhandled rejection if `promise` rejects AFTER the timeout
-    // wins the race — Promise.race settles on the first result but the
-    // losing promises still run, and any later rejection would be uncaught.
-    promise.catch(() => { });
-    try {
-        return await Promise.race([
-            promise,
-            new Promise((_, reject) => {
-                timeout = setTimeout(() => reject(new Error(`Timeout after ${timeoutMs}ms`)), timeoutMs);
-            }),
-        ]);
-    }
-    finally {
-        if (timeout)
-            clearTimeout(timeout);
-    }
-}
 function positiveIntFromEnv(name, fallback) {
     const raw = process.env[name];
     if (!raw)
@@ -1259,6 +1348,7 @@ function detectWorkspaceDiagnosticsSupport(initResult) {
         return {
             advertised: false,
             mode: "push-only",
+            workspaceDiagnostics: false,
             diagnosticProviderKind: "none",
         };
     }
@@ -1266,6 +1356,8 @@ function detectWorkspaceDiagnosticsSupport(initResult) {
         return {
             advertised: diagnosticProvider,
             mode: diagnosticProvider ? "pull" : "push-only",
+            // The boolean form of diagnosticProvider only signals document pull.
+            workspaceDiagnostics: false,
             diagnosticProviderKind: "boolean",
         };
     }
@@ -1273,12 +1365,15 @@ function detectWorkspaceDiagnosticsSupport(initResult) {
         return {
             advertised: true,
             mode: "pull",
+            workspaceDiagnostics: diagnosticProvider
+                .workspaceDiagnostics === true,
             diagnosticProviderKind: "object",
         };
     }
     return {
         advertised: false,
         mode: "push-only",
+        workspaceDiagnostics: false,
         diagnosticProviderKind: typeof diagnosticProvider,
     };
 }