pi-lens 3.1.2 → 3.2.0

package/clients/lsp/interactive-install.ts

@@ -1,8 +1,8 @@
 /**
  * Interactive LSP Installer
- * 
+ *
  * Provides lazy auto-install with user prompt for common languages.
- * 
+ *
  * Features:
  * - 30-second timeout with auto-accept
  * - --auto-install flag for non-interactive mode
@@ -10,17 +10,20 @@
  * - Only prompts for "common" languages (Go, Rust, YAML, JSON, Bash)
  */
 
-import * as fs from "fs/promises";
-import * as path from "path";
-import { spawn } from "child_process";
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 
 // Languages that support interactive auto-install prompt
-const COMMON_LANGUAGES: Record<string, {
-	toolId: string;
-	toolName: string;
-	installCommand: string;
-	packageName: string;
-}> = {
+const COMMON_LANGUAGES: Record<
+	string,
+	{
+		toolId: string;
+		toolName: string;
+		installCommand: string;
+		packageName: string;
+	}
+> = {
 	go: {
 		toolId: "gopls",
 		toolName: "Go Language Server (gopls)",
@@ -40,7 +43,7 @@ const COMMON_LANGUAGES: Record<string, {
 		packageName: "yaml-language-server",
 	},
 	json: {
-		toolId: "vscode-json-languageserver",
+		toolId: "vscode-json-language-server",
 		toolName: "JSON Language Server",
 		installCommand: "npm install -g vscode-langservers-extracted",
 		packageName: "vscode-langservers-extracted",
@@ -68,7 +71,9 @@ function getCachePath(cwd: string): string {
 /**
  * Read cached install choices
  */
-async function readChoices(cwd: string): Promise<Record<string, InstallChoice>> {
+async function readChoices(
+	cwd: string,
+): Promise<Record<string, InstallChoice>> {
 	try {
 		const cachePath = getCachePath(cwd);
 		const content = await fs.readFile(cachePath, "utf-8");
@@ -84,11 +89,11 @@ async function readChoices(cwd: string): Promise<Record<string, InstallChoice>>
 async function saveChoice(
 	cwd: string,
 	toolId: string,
-	choice: "yes" | "no" | "auto"
+	choice: "yes" | "no" | "auto",
 ): Promise<void> {
 	const choices = await readChoices(cwd);
 	choices[toolId] = { choice, timestamp: Date.now() };
-	
+
 	try {
 		const cachePath = getCachePath(cwd);
 		await fs.mkdir(path.dirname(cachePath), { recursive: true });
@@ -111,7 +116,7 @@ function promptUser(timeoutMs: number): Promise<"yes" | "no"> {
 		const onData = (data: Buffer | string) => {
 			const char = data.toString().trim().toLowerCase();
 			cleanup();
-			
+
 			if (char === "y" || char === "\n" || char === "\r") {
 				resolve("yes");
 			} else if (char === "n") {
@@ -148,16 +153,21 @@ function promptUser(timeoutMs: number): Promise<"yes" | "no"> {
  */
 function isAutoInstallEnabled(): boolean {
 	// Check environment variable or process arguments
-	return process.env.PI_LENS_AUTO_INSTALL === "1" ||
-		process.argv.includes("--auto-install");
+	return (
+		process.env.PI_LENS_AUTO_INSTALL === "1" ||
+		process.argv.includes("--auto-install")
+	);
 }
 
 /**
  * Attempt to install a tool
  */
-async function installTool(toolId: string, packageName: string): Promise<boolean> {
+async function installTool(
+	toolId: string,
+	packageName: string,
+): Promise<boolean> {
 	console.error(`[pi-lens] Installing ${toolId}...`);
-	
+
 	return new Promise((resolve) => {
 		const proc = spawn("npm", ["install", "-g", packageName], {
 			stdio: "inherit",
@@ -169,7 +179,9 @@ async function installTool(toolId: string, packageName: string): Promise<boolean
 				console.error(`[pi-lens] ✓ ${toolId} installed successfully`);
 				resolve(true);
 			} else {
-				console.error(`[pi-lens] ✗ ${toolId} installation failed (exit code ${code})`);
+				console.error(
+					`[pi-lens] ✗ ${toolId} installation failed (exit code ${code})`,
+				);
 				resolve(false);
 			}
 		});
@@ -183,14 +195,14 @@ async function installTool(toolId: string, packageName: string): Promise<boolean
 
 /**
  * Prompt user for installation with timeout, or auto-install if flag set
- * 
+ *
  * @param language - Language identifier (go, rust, yaml, json, bash)
  * @param cwd - Project root
  * @returns true if tool is/should be installed, false to skip
  */
 export async function promptForInstall(
 	language: string,
-	cwd: string
+	cwd: string,
 ): Promise<boolean> {
 	const config = COMMON_LANGUAGES[language];
 	if (!config) {
@@ -201,21 +213,34 @@ export async function promptForInstall(
 	// Check cache first
 	const choices = await readChoices(cwd);
 	const cached = choices[config.toolId];
-	
+
 	if (cached) {
 		// Cache valid for 30 days
 		const thirtyDays = 30 * 24 * 60 * 60 * 1000;
 		if (Date.now() - cached.timestamp < thirtyDays) {
 			if (cached.choice === "yes" || cached.choice === "auto") {
-				return true;
+				// Verify binary actually exists before trusting cache
+				try {
+					const { execSync } = await import("node:child_process");
+					execSync(`which ${config.toolId}`, { stdio: "ignore" });
+					return true; // Binary exists, cache is valid
+				} catch {
+					// Binary not found, invalidate cache and continue to install
+					console.error(
+						`[pi-lens] Cached ${config.toolId} not found, re-installing...`,
+					);
+				}
+			} else {
+				return false; // User previously declined
 			}
-			return false;
 		}
 	}
 
 	// Check auto-install flag
 	if (isAutoInstallEnabled()) {
-		console.error(`[pi-lens] Auto-install enabled, installing ${config.toolName}...`);
+		console.error(
+			`[pi-lens] Auto-install enabled, installing ${config.toolName}...`,
+		);
 		await saveChoice(cwd, config.toolId, "auto");
 		return await installTool(config.toolId, config.packageName);
 	}

package/clients/lsp/launch.js

@@ -6,18 +6,91 @@
  * - Node.js scripts (npx/bun)
  * - Package manager execution
  */
-import { spawn as nodeSpawn, } from "node:child_process";
+import { execSync, spawn as nodeSpawn, } from "node:child_process";
+import fs from "node:fs";
 import path from "node:path";
-// Helper to detect if running on Windows
 const isWindows = process.platform === "win32";
+/**
+ * Find binary in npm global directory
+ * Works around PATH caching issue after npm install -g
+ */
+function _findBinaryInNpmGlobal(command) {
+    try {
+        // Get npm global prefix
+        const prefix = execSync("npm prefix -g", { encoding: "utf-8" }).trim();
+        // On Windows, binaries are directly in the prefix dir
+        // On Unix, they're in prefix/bin
+        const binDir = isWindows ? prefix : path.join(prefix, "bin");
+        // Check for Windows variants
+        const candidates = isWindows
+            ? [
+                path.join(binDir, `${command}.cmd`),
+                path.join(binDir, `${command}.exe`),
+                path.join(binDir, command),
+            ]
+            : [path.join(binDir, command)];
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Try to spawn a process, throwing immediately if it fails
+ */
+function trySpawn(command, args, cwd, env, needsShell) {
+    let proc;
+    if (needsShell) {
+        // Use shell mode with quoted command
+        const shellCommand = `"${command}" ${args.map((a) => (a.includes(" ") ? `"${a}"` : a)).join(" ")}`;
+        proc = nodeSpawn(shellCommand, [], {
+            cwd,
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+            detached: false,
+            windowsHide: true,
+            shell: true,
+        });
+    }
+    else {
+        // Use normal spawn without shell
+        proc = nodeSpawn(command, args, {
+            cwd,
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+            detached: false,
+            windowsHide: isWindows,
+        });
+    }
+    if (!proc.stdin || !proc.stdout || !proc.stderr) {
+        throw new Error(`Failed to spawn LSP server: ${command}`);
+    }
+    // Check if process exited immediately (spawn failure - synchronous check)
+    if (proc.exitCode !== null || proc.killed) {
+        throw new Error(`LSP server ${command} exited immediately (code: ${proc.exitCode}). ` +
+            `The binary may be missing or corrupted.`);
+    }
+    return proc;
+}
 /**
  * Attach error handler to a spawned process to prevent ENOENT crashes
  * This catches "command not found" errors and other spawn failures
+ * Returns a promise that rejects if an immediate error occurs
  */
-function _attachErrorHandler(proc, context) {
+function _attachErrorHandler(proc, context, rejectOnImmediateError) {
     proc.on("error", (err) => {
         // Log the error but don't crash - the caller should handle this gracefully
         console.error(`[lsp] Spawn error for ${context}:`, err.message);
+        // If we have a reject function and this is an immediate spawn error, reject
+        if (rejectOnImmediateError &&
+            err.code === "ENOENT") {
+            rejectOnImmediateError(err);
+        }
     });
     // Also handle unexpected exit (process crash after successful spawn)
     proc.on("exit", (code, signal) => {
@@ -38,13 +111,14 @@ function _attachErrorHandler(proc, context) {
  * - Uses absolute paths (relative paths fail in shell mode)
  * - Uses shell: true for .cmd files
  * - Uses windowsHide to prevent console window popup
+ * - Detects immediate spawn failures (ENOENT) before returning
  *
  * @param command - Command to run (e.g., "typescript-language-server")
  * @param args - Arguments (e.g., ["--stdio"])
  * @param options - Spawn options including cwd, env
  * @returns LSPProcess handle
  */
-export function launchLSP(command, args = [], options = {}) {
+export async function launchLSP(command, args = [], options = {}) {
     const cwd = String(options.cwd ?? process.cwd());
     const env = { ...process.env, ...options.env };
     // Resolve command path
@@ -56,31 +130,53 @@ export function launchLSP(command, args = [], options = {}) {
         : command.includes(path.sep) || command.includes("/")
             ? path.resolve(cwd, command)
             : command; // Let system find it via PATH
-    // On Windows with shell: true, we need to quote the command if it has spaces
-    const needsShell = isWindows &&
-        (resolvedCommand.includes(" ") || resolvedCommand.includes(".cmd"));
+    // Compute needsShell based on command
+    // On Windows, shell: true is needed for .cmd/.bat files and extensionless binaries
+    // .exe files can be spawned directly, but .cmd/.bat require shell interpretation
+    const hasScriptExtension = /\.(cmd|bat)$/i.test(resolvedCommand);
+    let needsShell = isWindows &&
+        (resolvedCommand.includes(" ") ||
+            hasScriptExtension ||
+            !/\.(exe|cmd|bat)$/i.test(resolvedCommand));
+    // Try to spawn the process
+    // 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) &&
+        !command.includes(path.sep) &&
+        !command.includes("/")) {
+        const npmGlobalPath = _findBinaryInNpmGlobal(command);
+        if (npmGlobalPath) {
+            spawnCommand = npmGlobalPath;
+            // Recompute needsShell for npm global path
+            const globalHasExt = /\.(exe|cmd|bat)$/i.test(spawnCommand);
+            needsShell = isWindows && (spawnCommand.includes(" ") || !globalHasExt);
+        }
+    }
     let proc;
-    if (needsShell) {
-        // Use shell mode with quoted command
-        const shellCommand = `"${resolvedCommand}" ${args.map((a) => (a.includes(" ") ? `"${a}"` : a)).join(" ")}`;
-        proc = nodeSpawn(shellCommand, [], {
-            cwd,
-            env,
-            stdio: ["pipe", "pipe", "pipe"],
-            detached: false,
-            windowsHide: true,
-            shell: true,
-        });
+    try {
+        proc = trySpawn(spawnCommand, args, cwd, env, needsShell);
     }
-    else {
-        // Use normal spawn without shell
-        proc = nodeSpawn(resolvedCommand, args, {
-            cwd,
-            env,
-            stdio: ["pipe", "pipe", "pipe"],
-            detached: false,
-            windowsHide: isWindows,
-        });
+    catch (err) {
+        // If spawn failed with simple command, try npm global
+        if (!path.isAbsolute(command) &&
+            !command.includes(path.sep) &&
+            !command.includes("/")) {
+            const npmGlobalPath = _findBinaryInNpmGlobal(command);
+            if (npmGlobalPath && npmGlobalPath !== spawnCommand) {
+                console.error(`[lsp] Trying npm global: ${npmGlobalPath}`);
+                // Recompute needsShell for npm global path
+                const globalHasExt = /\.(exe|cmd|bat)$/i.test(npmGlobalPath);
+                const needsShellGlobal = isWindows && (npmGlobalPath.includes(" ") || !globalHasExt);
+                proc = trySpawn(npmGlobalPath, args, cwd, env, needsShellGlobal);
+            }
+            else {
+                throw err;
+            }
+        }
+        else {
+            throw err;
+        }
     }
     if (!proc.stdin || !proc.stdout || !proc.stderr) {
         throw new Error(`Failed to spawn LSP server: ${command}`);
@@ -90,7 +186,35 @@ export function launchLSP(command, args = [], options = {}) {
         throw new Error(`LSP server ${command} exited immediately (code: ${proc.exitCode}). ` +
             `The binary may be missing or corrupted.`);
     }
-    // Attach error handler to prevent ENOENT crashes and track later failures
+    // For Windows and certain spawn failures, the error is async (ENOENT)
+    // We need to wait a small tick to catch immediate spawn failures
+    await new Promise((resolve, reject) => {
+        let settled = false;
+        // Attach error handler that can reject for immediate errors
+        proc.on("error", (err) => {
+            if (!settled && err.code === "ENOENT") {
+                settled = true;
+                reject(new Error(`LSP server binary not found: ${command}. ` +
+                    `Install it or check your PATH.`));
+            }
+        });
+        // Also listen for immediate exit
+        proc.on("exit", (code) => {
+            if (!settled && code !== null) {
+                settled = true;
+                reject(new Error(`LSP server ${command} exited immediately with code ${code}. ` +
+                    `The binary may be missing or corrupted.`));
+            }
+        });
+        // Give it a small window to fail immediately (ENOENT on Windows is fast)
+        setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                resolve();
+            }
+        }, 50);
+    });
+    // Re-attach the permanent error handler now that we've passed the danger zone
     _attachErrorHandler(proc, command);
     return {
         process: proc,
@@ -103,7 +227,7 @@ export function launchLSP(command, args = [], options = {}) {
 /**
  * Spawn via package manager (npx/bun)
  */
-export function launchViaPackageManager(packageName, args = [], options = {}) {
+export async function launchViaPackageManager(packageName, args = [], options = {}) {
     // Prefer bun if available, fall back to npx (use .cmd on Windows)
     const isWin = process.platform === "win32";
     if (process.env.BUN_INSTALL) {
@@ -123,7 +247,33 @@ export function launchViaPackageManager(packageName, args = [], options = {}) {
             windowsHide: true,
             shell: true,
         });
-        // Attach error handler to prevent ENOENT crashes
+        if (!proc.stdin || !proc.stdout || !proc.stderr) {
+            throw new Error(`Failed to spawn package manager for: ${packageName}`);
+        }
+        // Check for immediate spawn failure on Windows
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            proc.on("error", (err) => {
+                if (!settled && err.code === "ENOENT") {
+                    settled = true;
+                    reject(new Error(`Package manager not found for: ${packageName}. ` +
+                        `Install Node.js or check your PATH.`));
+                }
+            });
+            proc.on("exit", (code) => {
+                if (!settled && code !== null) {
+                    settled = true;
+                    reject(new Error(`Package manager exited immediately for: ${packageName} (code: ${code})`));
+                }
+            });
+            setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    resolve();
+                }
+            }, 50);
+        });
+        // Attach permanent error handler
         _attachErrorHandler(proc, packageName);
         return {
             process: proc,
@@ -138,13 +288,13 @@ export function launchViaPackageManager(packageName, args = [], options = {}) {
 /**
  * Spawn via Node.js directly
  */
-export function launchViaNode(scriptPath, args = [], options = {}) {
+export async function launchViaNode(scriptPath, args = [], options = {}) {
     return launchLSP(process.execPath, [scriptPath, ...args], options);
 }
 /**
  * Spawn via Python module
  */
-export function launchViaPython(moduleName, args = [], options = {}) {
+export async function launchViaPython(moduleName, args = [], options = {}) {
     // On Windows, prefer 'py' launcher, fall back to 'python'
     const pythonCmd = process.platform === "win32" ? "py" : "python3";
     return launchLSP(pythonCmd, ["-m", moduleName, ...args], options);