pi-lens 3.8.52 → 3.8.53

package/dist/clients/installer/index.js

@@ -472,8 +472,10 @@ export const TOOLS = [
         installStrategy: "github",
         binaryName: "ktlint",
         github: {
-            // ktlint ships one universal binary "ktlint" for Linux/macOS (GraalVM native)
-            // and "ktlint.bat" for Windows (requires Java). No arm64-specific asset.
+            // ktlint ships a self-executable `ktlint` (a JAR with a shell preamble)
+            // for Linux/macOS, plus a `ktlint.bat` wrapper for Windows that runs
+            // `java -jar %~dp0ktlint`. On Windows BOTH files are needed: the .bat AND
+            // the `ktlint` jar it wraps (#218). No arm64-specific asset.
             repo: "pinterest/ktlint",
             assetMatch: (platform, _arch) => {
                 if (platform === "linux")
@@ -484,6 +486,24 @@ export const TOOLS = [
                     return "ktlint.bat";
                 return undefined;
             },
+            extraAssets: (platform) => (platform === "win32" ? ["ktlint"] : []),
+        },
+    },
+    {
+        // ktfmt (Meta's opinionated Kotlin formatter) ships only as a Maven-Central
+        // fat JAR — no native binary, no npm package — so it uses the maven strategy
+        // (#129). Run via a `java -jar` launcher; requires a JRE.
+        id: "ktfmt",
+        name: "ktfmt",
+        checkCommand: "ktfmt",
+        checkArgs: ["--version"],
+        installStrategy: "maven",
+        binaryName: "ktfmt",
+        maven: {
+            groupId: "com.facebook",
+            artifactId: "ktfmt",
+            version: "0.63",
+            classifier: "with-dependencies",
         },
     },
     {
@@ -959,12 +979,13 @@ export async function getAllToolStatuses() {
                 continue;
             }
         }
-        // 4. Check GitHub releases (~/.pi-lens/bin/)
-        if (tool.installStrategy === "github") {
+        // 4. Check managed bin (~/.pi-lens/bin/) — github releases + maven launchers
+        if (tool.installStrategy === "github" || tool.installStrategy === "maven") {
             const githubPath = await findGitHubToolPath(tool.binaryName || tool.id);
             if (githubPath) {
                 status.installed = true;
-                status.source = "github-release";
+                status.source =
+                    tool.installStrategy === "maven" ? "maven-jar" : "github-release";
                 status.path = githubPath;
                 statuses.push(status);
                 continue;
@@ -1048,11 +1069,11 @@ export async function getToolPath(toolId) {
     catch {
         // fall through to global checks
     }
-    // For github-strategy tools, prefer managed install (~/.pi-lens/bin/) over PATH.
-    // Managed installs are known-good binaries that pi-lens downloaded as a fallback
-    // when a PATH-resolved tool was broken or missing. Checking before PATH ensures
-    // force-reinstall flows find the newly downloaded binary.
-    if (tool.installStrategy === "github") {
+    // For github/maven tools, prefer the managed install (~/.pi-lens/bin/) over
+    // PATH. Managed installs are known-good binaries/launchers pi-lens downloaded
+    // as a fallback when a PATH-resolved tool was broken or missing. Checking
+    // before PATH ensures force-reinstall flows find the newly downloaded binary.
+    if (tool.installStrategy === "github" || tool.installStrategy === "maven") {
         const githubPath = await findGitHubToolPath(tool.binaryName || tool.id);
         if (githubPath)
             return githubPath;
@@ -1447,6 +1468,27 @@ async function installGitHubTool(tool) {
         logSessionStart(`github-install ${tool.id}: install failed: ${err.message}`);
         return undefined;
     }
+    // Download any sibling assets the primary wrapper depends on (e.g. ktlint's
+    // `ktlint` jar next to `ktlint.bat`, #218). Matched by EXACT name and written
+    // as bare files into the same dir; a missing one fails the install.
+    for (const extraName of spec.extraAssets?.(platform, arch) ?? []) {
+        const extraAsset = releaseJson.assets.find((a) => a.name === extraName);
+        if (!extraAsset) {
+            logSessionStart(`github-install ${tool.id}: required extra asset "${extraName}" not found`);
+            return undefined;
+        }
+        try {
+            const extraBuffer = await httpsGet(extraAsset.browser_download_url);
+            await fs.writeFile(path.join(GITHUB_BIN_DIR, extraName), extraBuffer, {
+                mode: 0o755,
+            });
+            logSessionStart(`github-install ${tool.id}: installed extra asset ${extraName} (${extraBuffer.length} bytes)`);
+        }
+        catch (err) {
+            logSessionStart(`github-install ${tool.id}: extra asset ${extraName} download failed: ${err.message}`);
+            return undefined;
+        }
+    }
     debugLog(`[github] installed ${tool.name} → ${destPath}`);
     logSessionStart(`github-install ${tool.id}: installed → ${destPath}`);
     return destPath;
@@ -1482,6 +1524,62 @@ const NEEDS_POSTINSTALL = new Set([
     "esbuild",
     "intelephense", // postinstall fetches platform binary; --ignore-scripts breaks install
 ]);
+const MAVEN_CENTRAL_BASE = "https://repo1.maven.org/maven2";
+/**
+ * Install a Maven-distributed runnable fat JAR: download it into the managed bin
+ * and write a `java -jar` launcher next to it (so it resolves like any managed
+ * binary via findGitHubToolPath). Requires a JRE — gated on `java` availability.
+ */
+async function installMavenTool(tool) {
+    const spec = tool.maven;
+    if (!spec)
+        return undefined;
+    const binaryName = tool.binaryName ?? tool.id;
+    const isWindows = process.platform === "win32";
+    if (!(await isCommandAvailable("java", ["-version"]))) {
+        logSessionStart(`maven-install ${tool.id}: java not found — a JAR tool can't run without a JRE`);
+        return undefined;
+    }
+    // Strip trailing slashes without a regex (the `\/+$` form trips ReDoS
+    // scanners — S5852 — even though the input is a trusted constant/registry
+    // value). A plain loop is unambiguously linear.
+    let base = spec.repoBaseUrl ?? MAVEN_CENTRAL_BASE;
+    while (base.endsWith("/"))
+        base = base.slice(0, -1);
+    const groupPath = spec.groupId.replace(/\./g, "/");
+    const jarFile = `${spec.artifactId}-${spec.version}${spec.classifier ? `-${spec.classifier}` : ""}.jar`;
+    const url = `${base}/${groupPath}/${spec.artifactId}/${spec.version}/${jarFile}`;
+    logSessionStart(`maven-install ${tool.id}: downloading ${url}`);
+    let jarBuffer;
+    try {
+        jarBuffer = await httpsGet(url);
+    }
+    catch (err) {
+        logSessionStart(`maven-install ${tool.id}: download failed: ${err.message}`);
+        return undefined;
+    }
+    try {
+        await fs.mkdir(GITHUB_BIN_DIR, { recursive: true });
+        const jarPath = path.join(GITHUB_BIN_DIR, `${tool.id}.jar`);
+        await fs.writeFile(jarPath, jarBuffer);
+        // Launcher so the tool resolves as a normal command in the managed bin.
+        const launcherName = isWindows ? `${binaryName}.bat` : binaryName;
+        const launcherPath = path.join(GITHUB_BIN_DIR, launcherName);
+        if (isWindows) {
+            await fs.writeFile(launcherPath, `@echo off\r\njava -jar "%~dp0${tool.id}.jar" %*\r\n`);
+        }
+        else {
+            await fs.writeFile(launcherPath, `#!/bin/sh\nexec java -jar "$(dirname "$0")/${tool.id}.jar" "$@"\n`, { mode: 0o755 });
+        }
+        logSessionStart(`maven-install ${tool.id}: installed → ${launcherPath} (${jarBuffer.length} bytes)`);
+        debugLog(`[maven] installed ${tool.name} → ${launcherPath}`);
+        return launcherPath;
+    }
+    catch (err) {
+        logSessionStart(`maven-install ${tool.id}: install failed: ${err.message}`);
+        return undefined;
+    }
+}
 async function installNpmTool(packageName, binaryName) {
     try {
         // Ensure tools directory exists
@@ -1798,6 +1896,14 @@ export async function installTool(toolId) {
                 logSessionStart(`auto-install ${tool.id}: ${ok ? "success" : "failed"} (${Date.now() - startedAt}ms)`);
                 return ok;
             }
+            case "maven": {
+                if (!tool.maven)
+                    return false;
+                const mavenPath = await installMavenTool(tool);
+                const ok = mavenPath !== undefined;
+                logSessionStart(`auto-install ${tool.id}: ${ok ? "success" : "failed"} (${Date.now() - startedAt}ms)`);
+                return ok;
+            }
             default:
                 logSessionStart(`auto-install ${tool.id}: unsupported strategy`);
                 return false;

package/dist/clients/language-policy.js

@@ -82,7 +82,7 @@ const PRIMARY_DISPATCH_GROUPS = {
         filterKinds: ["rust"],
     },
     ruby: {
-        mode: "fallback",
+        mode: "all",
         runnerIds: ["lsp", "rubocop"],
         filterKinds: ["ruby"],
     },
@@ -109,12 +109,12 @@ const PRIMARY_DISPATCH_GROUPS = {
         filterKinds: ["markdown"],
     },
     css: {
-        mode: "fallback",
+        mode: "all",
         runnerIds: ["lsp", "stylelint"],
         filterKinds: ["css"],
     },
     yaml: {
-        mode: "fallback",
+        mode: "all",
         runnerIds: ["lsp", "yamllint"],
         filterKinds: ["yaml"],
     },
@@ -124,12 +124,12 @@ const PRIMARY_DISPATCH_GROUPS = {
         filterKinds: ["sql"],
     },
     html: {
-        mode: "fallback",
+        mode: "all",
         runnerIds: ["lsp", "htmlhint"],
         filterKinds: ["html"],
     },
     docker: {
-        mode: "fallback",
+        mode: "all",
         runnerIds: ["lsp", "hadolint"],
         filterKinds: ["docker"],
     },
@@ -160,7 +160,7 @@ const PRIMARY_DISPATCH_GROUPS = {
         filterKinds: ["java"],
     },
     kotlin: {
-        mode: "fallback",
+        mode: "all",
         runnerIds: ["lsp", "ktlint"],
         filterKinds: ["kotlin"],
     },
@@ -196,7 +196,7 @@ const PRIMARY_DISPATCH_GROUPS = {
     },
     nix: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["nix"] },
     toml: {
-        mode: "fallback",
+        mode: "all",
         runnerIds: ["lsp", "taplo"],
         filterKinds: ["toml"],
     },

package/dist/clients/lsp/client.js

@@ -12,7 +12,9 @@ import { EventEmitter } from "node:events";
 import { access } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 import { logLatency } from "../latency-logger.js";
-import { createMessageConnection, StreamMessageReader, StreamMessageWriter, } from "vscode-jsonrpc/node.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.
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter, } from "vscode-jsonrpc/node";
 import { normalizeMapKey, uriToPath } from "./path-utils.js";
 import { getStrategy } from "./server-strategies.js";
 // --- Constants ---

package/dist/clients/lsp/server.js

@@ -71,7 +71,7 @@ function logSessionStart(message) {
         // best-effort logging
     });
 }
-async function resolveAndLaunch(spec, allowInstall) {
+export async function resolveAndLaunch(spec, allowInstall) {
     const toolLabel = spec.managedToolId ??
         spec.candidates[spec.candidates.length - 1] ??
         "unknown";
@@ -82,6 +82,12 @@ async function resolveAndLaunch(spec, allowInstall) {
             lastRuntimeFailure = err instanceof Error ? err : new Error(message);
         }
     };
+    // A candidate that fails while a LATER candidate (or managed install)
+    // succeeds is just fallback, not a failure — logging each immediately floods
+    // the logs with scary "candidate failed / npm shim failed / Run npm install"
+    // lines that read as smells even though the launch succeeded. Collect them and
+    // surface only if ALL direct candidates fail.
+    const candidateFailures = [];
     // Step 1 & 2 — try all explicit candidates (includes bare command = PATH lookup)
     for (const [index, command] of spec.candidates.entries()) {
         logLatency({
@@ -120,23 +126,29 @@ async function resolveAndLaunch(spec, allowInstall) {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            logLatency({
-                type: "phase",
-                phase: "lsp_launch_candidate_failed",
-                filePath: spec.cwd,
-                durationMs: 0,
-                metadata: {
-                    tool: toolLabel,
-                    command,
-                    index,
-                    error: message,
-                },
-            });
-            logSessionStart(`lsp launch candidate failed tool=${toolLabel} idx=${index} command=${command} error=${message}`);
-            trackRuntimeFailure(err);
+            // Defer logging: only a failure if no later candidate/install succeeds.
+            candidateFailures.push({ index, command, message, err });
             // try next
         }
     }
+    // All direct candidates failed (a successful one returns above). Surface the
+    // deferred failures now so the all-failed case stays fully diagnosable.
+    for (const failure of candidateFailures) {
+        logLatency({
+            type: "phase",
+            phase: "lsp_launch_candidate_failed",
+            filePath: spec.cwd,
+            durationMs: 0,
+            metadata: {
+                tool: toolLabel,
+                command: failure.command,
+                index: failure.index,
+                error: failure.message,
+            },
+        });
+        logSessionStart(`lsp launch candidate failed tool=${toolLabel} idx=${failure.index} command=${failure.command} error=${failure.message}`);
+        trackRuntimeFailure(failure.err);
+    }
     if (!canInstall(allowInstall)) {
         logSessionStart(`lsp launch install blocked tool=${toolLabel} cwd=${spec.cwd} allowInstall=${allowInstall !== false} globalDisabled=${isLspInstallDisabled()}`);
         logLatency({

package/dist/clients/pipeline.js

@@ -21,7 +21,8 @@ import { getDiagnosticLogger } from "./diagnostic-logger.js";
 import { getDiagnosticTracker } from "./diagnostic-tracker.js";
 import { computeCascadeForFile, dispatchLintWithResult, } from "./dispatch/integration.js";
 import { toRunnerDisplayPath } from "./dispatch/runner-context.js";
-import { resolveCommandArgsWithInstallFallback, resolveToolCommand, resolveToolCommandWithInstallFallback, } from "./dispatch/runners/utils/runner-helpers.js";
+import { createAvailabilityChecker, resolveAvailableOrInstall, resolveCommandArgsWithInstallFallback, resolveToolCommand, resolveToolCommandWithInstallFallback, } from "./dispatch/runners/utils/runner-helpers.js";
+import { findDetektConfig } from "./dispatch/runners/detekt.js";
 import { detectFileKind, getFileKindLabel } from "./file-kinds.js";
 import { detectFileChangedAfterCommand, getProjectIgnoreMatcher, isExcludedDirName, } from "./file-utils.js";
 import { logLatency } from "./latency-logger.js";
@@ -31,7 +32,7 @@ import { clearGraphCache } from "./review-graph/builder.js";
 import { RUNTIME_CONFIG } from "./runtime-config.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 import { formatSecrets, scanForSecrets } from "./secrets-scanner.js";
-import { getAutofixPolicyForFile, getPreferredAutofixTools, getRubocopCommand, hasBiomeConfig, hasEslintConfig, hasRubocopConfig, hasSqlfluffConfig, hasStylelintConfig, } from "./tool-policy.js";
+import { getAutofixPolicyForFile, getPreferredAutofixTools, getRubocopCommand, hasBiomeConfig, hasDetektConfig, hasEslintConfig, hasGolangciConfig, hasKtfmtConfig, hasOxlintConfig, hasRubocopConfig, hasSqlfluffConfig, hasStylelintConfig, } from "./tool-policy.js";
 const LSP_MAX_FILE_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
 const LSP_MAX_FILE_LINES = RUNTIME_CONFIG.pipeline.lspMaxFileLines;
 const LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;
@@ -173,20 +174,26 @@ async function tryEslintFix(filePath, cwd) {
     if (dry.status === 2)
         return 0;
     let fixableCount = 0;
+    let anyDryRunOutput = false;
     try {
         const results = JSON.parse(dry.stdout);
         fixableCount = results.reduce((sum, r) => sum + (r.fixableErrorCount ?? 0) + (r.fixableWarningCount ?? 0), 0);
+        // `--fix-dry-run` reports the POST-fix state: when every problem is
+        // auto-fixable, `messages`/`fixableErrorCount` are 0 and the fixed source
+        // lands in the `output` field instead. Keying on `fixableErrorCount` alone
+        // therefore misses the common "all fixable" case and never applies fixes.
+        anyDryRunOutput = results.some((r) => typeof r.output === "string");
     }
     catch {
         /* treat as zero fixable on error */
     }
-    if (fixableCount === 0)
+    if (fixableCount === 0 && !anyDryRunOutput)
         return 0;
     // Apply the fixes
     const fix = await safeSpawnAsync(cmd, ["--fix", "--no-error-on-unmatched-pattern", ...configArgs, filePath], { timeout: 30000, cwd });
     if (fix.status === 2)
         return 0;
-    return fixableCount;
+    return fixableCount > 0 ? fixableCount : anyDryRunOutput ? 1 : 0;
 }
 async function tryStylelintFix(filePath, cwd) {
     const cmd = await resolveToolCommandWithInstallFallback(cwd, "stylelint");
@@ -216,6 +223,56 @@ async function tryKtlintFix(filePath, cwd) {
         return 0;
     return detectFileChangedAfterCommand(filePath, cmd, ["-F", filePath], cwd, [1]);
 }
+// golangci-lint/detekt/ktfmt have no TOOL_COMMAND_SPEC; resolve via availability
+// checkers like their runners do.
+const golangciAutofixChecker = createAvailabilityChecker("golangci-lint", ".exe");
+const detektAutofixChecker = createAvailabilityChecker("detekt", ".bat");
+const ktfmtAutofixChecker = createAvailabilityChecker("ktfmt", ".bat");
+async function tryKtfmtFix(filePath, cwd) {
+    // Config-first: the autofix policy only reaches here when the project opted
+    // into ktfmt, so resolveAvailableOrInstall honors that gate. ktfmt writes the
+    // formatted file in place and exits 0; treat any byte change as the fix.
+    const cmd = await resolveAvailableOrInstall(ktfmtAutofixChecker, "ktfmt", cwd);
+    if (!cmd)
+        return 0;
+    const absPath = path.resolve(cwd, filePath);
+    return detectFileChangedAfterCommand(filePath, cmd, [absPath], cwd, [0]);
+}
+async function tryGolangciLintFix(filePath, cwd) {
+    // Config-first: the autofix policy only reaches here when a .golangci.* config
+    // exists. resolveAvailableOrInstall honors that gate (won't auto-install a
+    // config-first tool). golangci-lint exits non-zero when issues remain after
+    // --fix, so allow its issue-found codes.
+    const cmd = await resolveAvailableOrInstall(golangciAutofixChecker, "golangci-lint", cwd);
+    if (!cmd)
+        return 0;
+    return detectFileChangedAfterCommand(filePath, cmd, ["run", "--fix", filePath], cwd, [1, 7]);
+}
+async function tryDetektFix(filePath, cwd) {
+    const configPath = findDetektConfig(cwd);
+    if (!configPath)
+        return 0;
+    if (!(await detektAutofixChecker.isAvailableAsync(cwd)))
+        return 0;
+    const cmd = detektAutofixChecker.getCommand(cwd);
+    if (!cmd)
+        return 0;
+    const absPath = path.resolve(cwd, filePath);
+    return detectFileChangedAfterCommand(filePath, cmd, ["--auto-correct", "--input", absPath, "--config", configPath], cwd, [1, 2]);
+}
+async function tryMarkdownlintFix(filePath, cwd) {
+    const cmd = await resolveToolCommandWithInstallFallback(cwd, "markdownlint");
+    if (!cmd)
+        return 0;
+    // markdownlint-cli2 --fix exits non-zero when unfixable violations remain.
+    return detectFileChangedAfterCommand(filePath, cmd, ["--fix", filePath], cwd, [1]);
+}
+async function tryOxlintFix(filePath, cwd) {
+    const cmd = await resolveToolCommandWithInstallFallback(cwd, "oxlint");
+    if (!cmd)
+        return 0;
+    return detectFileChangedAfterCommand(filePath, cmd, ["--fix", filePath], cwd, [1]);
+}
 async function tryRustClippyFix(filePath) {
     const check = await safeSpawnAsync("cargo", ["--version"], { timeout: 5000 });
     if (check.error || check.status !== 0)
@@ -248,7 +305,7 @@ async function tryDartFix(filePath) {
     return diffProjectSnapshot(pubspecDir, before);
 }
 // --- Pipeline phase helpers ---
-async function runAutofix(filePath, cwd, getFlag, dbg, deps) {
+export async function runAutofix(filePath, cwd, getFlag, dbg, deps) {
     const { biomeClient, ruffClient, fixedThisTurn } = deps;
     const noAutofix = getFlag("no-autofix");
     let fixedCount = 0;
@@ -285,6 +342,10 @@ async function runAutofix(filePath, cwd, getFlag, dbg, deps) {
         hasSqlfluffConfig: hasSqlfluffConfig(cwd),
         hasRubocopConfig: hasRubocopConfig(cwd),
         hasBiomeConfig: hasBiomeConfig(cwd),
+        hasGolangciConfig: hasGolangciConfig(cwd),
+        hasDetektConfig: hasDetektConfig(cwd),
+        hasKtfmtConfig: hasKtfmtConfig(cwd),
+        hasOxlintConfig: hasOxlintConfig(cwd),
     };
     const autofixPolicy = getAutofixPolicyForFile(filePath, autofixContext);
     const preferredAutofixTools = autofixPolicy?.safe
@@ -438,6 +499,67 @@ async function runAutofix(filePath, cwd, getFlag, dbg, deps) {
                 dbg(`autofix: dart fix changed ${dartChangedFiles.length} file(s) from ${filePath}`);
                 needsContentRefresh = true;
             }
+            continue;
+        }
+        if (toolName === "golangci-lint") {
+            const fixed = await tryGolangciLintFix(filePath, cwd);
+            if (fixed > 0) {
+                fixedCount += fixed;
+                autofixTools.push(`golangci-lint:${fixed}`);
+                fixedThisTurn.add(filePath);
+                markTargetChanged();
+                dbg(`autofix: golangci-lint fixed ${filePath}`);
+                needsContentRefresh = true;
+            }
+            continue;
+        }
+        if (toolName === "detekt") {
+            const fixed = await tryDetektFix(filePath, cwd);
+            if (fixed > 0) {
+                fixedCount += fixed;
+                autofixTools.push(`detekt:${fixed}`);
+                fixedThisTurn.add(filePath);
+                markTargetChanged();
+                dbg(`autofix: detekt --auto-correct fixed ${filePath}`);
+                needsContentRefresh = true;
+            }
+            continue;
+        }
+        if (toolName === "ktfmt") {
+            const fixed = await tryKtfmtFix(filePath, cwd);
+            if (fixed > 0) {
+                fixedCount += fixed;
+                autofixTools.push(`ktfmt:${fixed}`);
+                fixedThisTurn.add(filePath);
+                markTargetChanged();
+                dbg(`autofix: ktfmt formatted ${filePath}`);
+                needsContentRefresh = true;
+            }
+            continue;
+        }
+        if (toolName === "markdownlint") {
+            const fixed = await tryMarkdownlintFix(filePath, cwd);
+            if (fixed > 0) {
+                fixedCount += fixed;
+                autofixTools.push(`markdownlint:${fixed}`);
+                fixedThisTurn.add(filePath);
+                markTargetChanged();
+                dbg(`autofix: markdownlint --fix fixed ${filePath}`);
+                needsContentRefresh = true;
+            }
+            continue;
+        }
+        if (toolName === "oxlint") {
+            const fixed = await tryOxlintFix(filePath, cwd);
+            if (fixed > 0) {
+                fixedCount += fixed;
+                autofixTools.push(`oxlint:${fixed}`);
+                fixedThisTurn.add(filePath);
+                markTargetChanged();
+                dbg(`autofix: oxlint --fix fixed ${filePath}`);
+                needsContentRefresh = true;
+            }
+            continue;
         }
     }
     if (attemptedTools.length > 0 && autofixTools.length === 0) {

package/dist/clients/safe-spawn.js

@@ -47,6 +47,22 @@ function cmdEscapeArg(arg) {
         return arg;
     return `"${arg.replace(/"/g, '""')}"`;
 }
+/**
+ * Build the cmd.exe command string used for Windows `shell:true` spawning.
+ *
+ * The COMMAND must be escaped the same way as the args — escaping only the args
+ * (the bug behind #214) means a tool whose resolved path contains a space (e.g.
+ * `C:\Program Files\Go\bin\go.exe`) makes cmd.exe parse `C:\Program` as the
+ * command and fail with "'C:\Program' is not recognized". `cmdEscapeArg` is a
+ * no-op for space-free commands, so this is safe for the npm/.pi-lens tool paths
+ * that already worked. The `chcp 65001` prefix forces the UTF-8 code page (so
+ * tool output isn't mangled by the system code page) and, as a side benefit,
+ * keeps the (possibly quoted) command off the front of the line, avoiding
+ * cmd.exe's `/s` outer-quote-stripping quirk.
+ */
+export function buildWindowsShellCommand(command, args) {
+    return `chcp 65001 >nul 2>&1 && ${[command, ...args].map(cmdEscapeArg).join(" ")}`;
+}
 // ============================================================================
 // ASYNC VERSION (Recommended - Non-blocking)
 // ============================================================================
@@ -93,7 +109,7 @@ export async function safeSpawnAsync(command, args, options) {
         // etc.) have their bytes decoded as the system code page (CP850/CP1252/
         // CP936/CP932), producing garbled characters in stderr error messages.
         const spawnCmd = isWindows
-            ? `chcp 65001 >nul 2>&1 && ${[command, ...args.map(cmdEscapeArg)].join(" ")}`
+            ? buildWindowsShellCommand(command, args)
             : command;
         const spawnArgs = isWindows ? [] : args;
         const child = spawn(spawnCmd, spawnArgs, {