@indy2kro/agentenv 1.0.1 → 1.1.0

package/dist/shell/detector.js

@@ -7,6 +7,7 @@ import * as path from 'path';
 import * as winPath from 'path/win32';
 import * as child_process from 'child_process';
 import { AGENT_KEYS } from '../config/schema.js';
+import { homeDir } from '../adapters/agent-dirs.js';
 import { getShimsDirValue, pathContainsDir, removeShimsDirValue } from '../toolchain/mise.js';
 import { writeFileWithRetry } from '../utils/fs-retry.js';
 import { clearShellFixState, mergeShellFixEntries, readShellFixState, shellFixStatePath, writeShellFixState, } from './shell-fix-state.js';
@@ -28,7 +29,7 @@ export const POSIX_UTILITIES = [
     'mv',
     'less',
 ];
-// Well-known paths for Git Bash on Windows
+// Well-known machine-wide paths for Git Bash on Windows
 export const GIT_BASH_PATHS = [
     'C:\\Program Files\\Git\\bin',
     'C:\\Program Files\\Git\\usr\\bin',
@@ -36,9 +37,67 @@ export const GIT_BASH_PATHS = [
     'C:\\Program Files (x86)\\Git\\usr\\bin',
 ];
 /**
- * Detect the current shell environment
+ * Candidate Git Bash directories: the well-known machine-wide paths plus
+ * per-user (`%LOCALAPPDATA%\Programs\Git`, the default for a non-admin Git
+ * for Windows install) and scoop install locations, which vary per machine
+ * and so can't be hardcoded in GIT_BASH_PATHS.
  */
-export function detectShell() {
+export function gitBashCandidatePaths(env = process.env) {
+    const candidates = [...GIT_BASH_PATHS];
+    const localAppData = env.LOCALAPPDATA;
+    if (localAppData) {
+        candidates.push(path.join(localAppData, 'Programs', 'Git', 'bin'), path.join(localAppData, 'Programs', 'Git', 'usr', 'bin'));
+    }
+    const scoopRoot = env.SCOOP || (env.USERPROFILE ? path.join(env.USERPROFILE, 'scoop') : undefined);
+    if (scoopRoot) {
+        candidates.push(path.join(scoopRoot, 'apps', 'git', 'current', 'bin'), path.join(scoopRoot, 'apps', 'git', 'current', 'usr', 'bin'));
+    }
+    return candidates;
+}
+/**
+ * Fall back to searching PATH for git.exe when none of the well-known
+ * install locations exist — covers custom install directories the
+ * candidate list can't anticipate. Derives the Git Bash root from git.exe's
+ * location (`<root>\cmd\git.exe` or `<root>\bin\git.exe`) and checks that
+ * root's `bin` and `usr\bin` directories.
+ */
+export function findGitBashOnPath(spawnSync = child_process.spawnSync) {
+    try {
+        const where = spawnSync('cmd.exe', ['/c', 'where', 'git'], {
+            encoding: 'utf8',
+            timeout: 5000,
+        });
+        if (where.status !== 0 || !where.stdout) {
+            return undefined;
+        }
+        const gitExe = where.stdout
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .find((line) => line.length > 0);
+        if (!gitExe) {
+            return undefined;
+        }
+        const root = path.dirname(path.dirname(gitExe));
+        for (const sub of ['bin', path.join('usr', 'bin')]) {
+            const candidate = path.join(root, sub);
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Detect the current shell environment.
+ *
+ * `spawnSync` is injectable (defaults to the real `child_process.spawnSync`)
+ * purely so tests can observe — and assert nothing installs anything through
+ * — the one remaining subprocess call this function makes directly.
+ */
+export function detectShell(spawnSync = child_process.spawnSync) {
     const isWindows = process.platform === 'win32';
     const isMacOS = process.platform === 'darwin';
     const currentShell = determineCurrentShell();
@@ -58,7 +117,7 @@ export function detectShell() {
         // Find Git Bash path (used by the Tier 0 fix even when the current shell
         // is PowerShell/cmd, so agents get pointed at a real POSIX shell).
         // Use path.resolve() to handle paths with spaces properly.
-        for (const gitPath of GIT_BASH_PATHS) {
+        for (const gitPath of gitBashCandidatePaths()) {
             try {
                 const resolvedPath = path.resolve(gitPath);
                 if (fs.existsSync(resolvedPath)) {
@@ -70,31 +129,36 @@ export function detectShell() {
                 // Ignore
             }
         }
+        // None of the well-known install locations exist: search PATH itself,
+        // which covers custom install directories.
+        if (!gitBashPath) {
+            gitBashPath = findGitBashOnPath(spawnSync);
+        }
     }
     else if (isMacOS) {
-        // On macOS, check for GNU coreutils
+        // On macOS, check for GNU coreutils. detectShell() must stay read-only —
+        // status/doctor call it too, and both are documented as never changing
+        // the machine — so it only ever detects, never installs. Installing is
+        // fixShellConfiguration()'s job (the explicit, reported Tier 0 apply
+        // step), which calls installGNUCoreutilsMacOS() itself when needed.
         isPosixCompatible = checkGNUCoreutils();
-        // If GNU coreutils are not available, we may need to install them
-        if (!isPosixCompatible) {
-            gnubinPath = installGNUCoreutilsMacOS();
-            if (gnubinPath) {
-                isPosixCompatible = true;
-            }
-        }
-        else {
-            // Try to get the gnubin path if coreutils are installed
-            try {
-                const result = child_process.spawnSync('brew', ['--prefix', 'coreutils'], {
-                    encoding: 'utf-8',
-                    stdio: ['ignore', 'pipe', 'pipe'],
-                });
+        // Read-only probe: report the gnubin path when coreutils happen to
+        // already be installed via Homebrew; do nothing (and no error) otherwise.
+        try {
+            const result = spawnSync('brew', ['--prefix', 'coreutils'], {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'pipe'],
+                timeout: 10000,
+            });
+            if (result.status === 0) {
                 const prefix = result.stdout.trim();
-                gnubinPath = path.join(prefix, 'libexec', 'gnubin');
-            }
-            catch {
-                // coreutils not installed via Homebrew, or Homebrew not available
+                if (prefix)
+                    gnubinPath = path.join(prefix, 'libexec', 'gnubin');
             }
         }
+        catch {
+            // coreutils not installed via Homebrew, or Homebrew not available
+        }
     }
     else {
         // On Linux and other Unix-like systems, check for GNU coreutils
@@ -165,7 +229,7 @@ function checkGitBash() {
         }
         // Check PATH for Git Bash directories (spaces-safe, case-folded on win32)
         const pathEnv = process.env.PATH || '';
-        for (const gitPath of GIT_BASH_PATHS) {
+        for (const gitPath of gitBashCandidatePaths()) {
             if (pathContainsDir(pathEnv, gitPath)) {
                 return true;
             }
@@ -192,11 +256,13 @@ export function checkGNUCoreutils() {
         const grepResult = child_process.spawnSync('sh', ['-c', 'command -v grep'], {
             encoding: 'utf-8',
             stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: 5000,
         });
         const grepPath = grepResult.stdout.trim();
         if (grepPath) {
             const grepCheck = child_process.spawnSync(grepPath, ['-P', '--version'], {
                 stdio: 'ignore',
+                timeout: 5000,
             });
             if (grepCheck.status === 0)
                 return true;
@@ -205,10 +271,14 @@ export function checkGNUCoreutils() {
         const sedResult = child_process.spawnSync('sh', ['-c', 'command -v sed'], {
             encoding: 'utf-8',
             stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: 5000,
         });
         const sedPath = sedResult.stdout.trim();
         if (sedPath) {
-            const sedCheck = child_process.spawnSync(sedPath, ['--version'], { stdio: 'ignore' });
+            const sedCheck = child_process.spawnSync(sedPath, ['--version'], {
+                stdio: 'ignore',
+                timeout: 5000,
+            });
             if (sedCheck.status === 0)
                 return true;
         }
@@ -228,7 +298,10 @@ function installGNUCoreutilsMacOS() {
     }
     try {
         // Check if Homebrew is installed
-        const brewOk = child_process.spawnSync('sh', ['-c', 'command -v brew'], { stdio: 'ignore' });
+        const brewOk = child_process.spawnSync('sh', ['-c', 'command -v brew'], {
+            stdio: 'ignore',
+            timeout: 5000,
+        });
         if (brewOk.status !== 0) {
             return undefined;
         }
@@ -238,15 +311,22 @@ function installGNUCoreutilsMacOS() {
             // Only install when the formula is not already installed
             const listed = child_process.spawnSync('brew', ['list', '--formula', pkg], {
                 stdio: 'ignore',
+                timeout: 10000,
             });
             if (listed.status !== 0) {
-                child_process.spawnSync('brew', ['install', '--quiet', pkg], { stdio: 'ignore' });
+                // An actual package install (network + possibly a build), unlike the
+                // read-only probes around it — given more room before we give up.
+                child_process.spawnSync('brew', ['install', '--quiet', pkg], {
+                    stdio: 'ignore',
+                    timeout: 120000,
+                });
             }
         }
         // Get the gnubin path from coreutils
         const result = child_process.spawnSync('brew', ['--prefix', 'coreutils'], {
             encoding: 'utf-8',
             stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: 10000,
         });
         if (result.status !== 0) {
             return undefined;
@@ -270,11 +350,17 @@ export function checkMissingUtilities(isPosixCompatible) {
     for (const util of POSIX_UTILITIES) {
         // `where` reports "not found" via a non-zero exit code (the INFO text goes
         // to stderr), so checking the exit status is what distinguishes "found".
-        const where = child_process.spawnSync('cmd.exe', ['/c', 'where', util], { stdio: 'ignore' });
+        const where = child_process.spawnSync('cmd.exe', ['/c', 'where', util], {
+            stdio: 'ignore',
+            timeout: 5000,
+        });
         if (where.status === 0) {
             continue;
         }
-        const which = child_process.spawnSync('sh', ['-c', `command -v ${util}`], { stdio: 'ignore' });
+        const which = child_process.spawnSync('sh', ['-c', `command -v ${util}`], {
+            stdio: 'ignore',
+            timeout: 5000,
+        });
         if (which.status === 0) {
             continue;
         }
@@ -333,15 +419,110 @@ export function getShellConfiguration(shellInfo) {
     };
 }
 /**
- * Generate PATH addition for Git Bash on Windows
+ * The Git for Windows install root for a detected Git Bash directory
+ * (`<root>\bin` or `<root>\usr\bin`), or undefined for any other shape.
+ * Uses win32 path semantics so it is correct regardless of host OS.
+ */
+export function gitInstallRoot(gitBashPath) {
+    if (winPath.basename(gitBashPath).toLowerCase() !== 'bin')
+        return undefined;
+    const parent = winPath.dirname(gitBashPath);
+    return winPath.basename(parent).toLowerCase() === 'usr' ? winPath.dirname(parent) : parent;
+}
+/**
+ * The PATH entries that expose Git for Windows' GNU tools (sed, grep, awk,
+ * xargs, ...) to native Windows shells: `<root>\mingw64\bin;<root>\usr\bin`.
+ * Returns '' when the Git root can't be derived from `gitBashPath`.
  */
 export function generateGitBashPathAddition(gitBashPath) {
-    if (process.platform !== 'win32') {
+    const root = gitInstallRoot(gitBashPath);
+    if (!root)
         return '';
+    return `${winPath.join(root, 'mingw64', 'bin')};${winPath.join(root, 'usr', 'bin')}`;
+}
+/**
+ * GNU tools agents most often reach for in shell commands. On Windows these
+ * only resolve from PowerShell/cmd when Git's `usr\bin` is on PATH, which
+ * Git's installer does not do by default.
+ */
+export const NATIVE_UNIX_TOOLS = [
+    'grep',
+    'sed',
+    'awk',
+    'find',
+    'xargs',
+    'diff',
+    'head',
+    'tail',
+    'wc',
+];
+/**
+ * Resolve `tool` the way cmd.exe/PowerShell would: first PATH entry holding
+ * `tool` + a PATHEXT extension wins. `exists` is injectable for tests.
+ */
+export function resolveOnWindowsPath(tool, pathVar, pathExt = '.COM;.EXE;.BAT;.CMD', exists = fs.existsSync) {
+    const extensions = pathExt.split(';').filter((ext) => ext.trim() !== '');
+    for (const rawDir of pathVar.split(';')) {
+        const dir = rawDir.trim().replace(/^"(.*)"$/, '$1');
+        if (dir === '')
+            continue;
+        for (const ext of extensions) {
+            const candidate = winPath.join(dir, `${tool}${ext.toLowerCase()}`);
+            if (exists(candidate))
+                return candidate;
+        }
     }
-    const binPath = path.join(gitBashPath, '..', 'mingw64', 'bin');
-    const usrBinPath = path.join(gitBashPath, '..', 'usr', 'bin');
-    return `${binPath};${usrBinPath}`;
+    return undefined;
+}
+const PERSISTENT_PATH_KEYS = [
+    'HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment',
+    'HKCU\\Environment',
+];
+/**
+ * The persistent machine + user PATH from the registry — what a freshly
+ * started PowerShell/cmd (and any agent launched from one) sees, unlike
+ * process.env.PATH, which already includes Git's dirs when agentenv itself
+ * runs inside Git Bash. `%VAR%` references are expanded from `env`.
+ * Returns undefined when neither key could be read.
+ */
+export function readPersistentWindowsPath(spawnSync = child_process.spawnSync, env = process.env) {
+    const parts = [];
+    for (const key of PERSISTENT_PATH_KEYS) {
+        try {
+            const result = spawnSync('reg', ['query', key, '/v', 'Path'], {
+                encoding: 'utf8',
+                timeout: 5000,
+            });
+            if (result.status !== 0 || typeof result.stdout !== 'string')
+                continue;
+            const match = /^\s*Path\s+REG_(?:EXPAND_)?SZ\s+(.*)$/im.exec(result.stdout);
+            if (match)
+                parts.push(match[1].trim());
+        }
+        catch {
+            // Key unreadable; fall through to the other one
+        }
+    }
+    if (parts.length === 0)
+        return undefined;
+    const lookup = new Map(Object.entries(env).map(([name, value]) => [name.toLowerCase(), value]));
+    return parts
+        .join(';')
+        .replace(/%([^%;]+)%/g, (whole, name) => lookup.get(name.toLowerCase()) ?? whole);
+}
+/**
+ * When `shell` is Git's raw MSYS bash (`<root>\usr\bin\bash.exe`) and the
+ * `<root>\bin\bash.exe` launcher exists, return the launcher. The raw binary
+ * started as a plain `bash -c` gets neither MSYSTEM nor `/usr/bin` on PATH,
+ * so sed/grep/awk resolve to nothing; the launcher sets both up.
+ */
+export function preferredGitBashLauncher(shell, exists = fs.existsSync) {
+    const normalized = shell.replace(/\//g, '\\');
+    if (!/\\usr\\bin\\bash\.exe$/i.test(normalized))
+        return undefined;
+    const root = winPath.dirname(winPath.dirname(winPath.dirname(normalized)));
+    const launcher = winPath.join(root, 'bin', 'bash.exe');
+    return exists(launcher) ? launcher : undefined;
 }
 /**
  * Generate PATH addition for GNU coreutils on macOS
@@ -360,18 +541,19 @@ function priorField(key, previous, set) {
 /**
  * Resolve the full path to bash.exe from a detected Git Bash directory.
  * Handles both the `usr\bin` form and the plain `bin` form Git for Windows ships.
+ * Prefers the `<root>\bin\bash.exe` launcher, which sets MSYSTEM and puts
+ * `/usr/bin` + `/mingw64/bin` on PATH; the raw `<root>\usr\bin\bash.exe` does
+ * neither for a non-login `bash -c`, so GNU tools go missing. Falls back to
+ * the raw binary only when the launcher isn't there.
  * Uses win32 path semantics so the result is correct regardless of host OS
  * (the tests exercise this on Linux CI).
  */
-export function bashExecutable(gitBashPath) {
-    const parent = winPath.dirname(gitBashPath);
-    if (winPath.basename(gitBashPath).toLowerCase() === 'bin') {
-        if (winPath.basename(parent).toLowerCase() === 'usr') {
-            return winPath.join(gitBashPath, 'bash.exe');
-        }
-        return winPath.join(parent, 'usr', 'bin', 'bash.exe');
-    }
-    return winPath.join(gitBashPath, 'bash.exe');
+export function bashExecutable(gitBashPath, exists = fs.existsSync) {
+    const root = gitInstallRoot(gitBashPath);
+    if (!root)
+        return winPath.join(gitBashPath, 'bash.exe');
+    const launcher = winPath.join(root, 'bin', 'bash.exe');
+    return exists(launcher) ? launcher : winPath.join(root, 'usr', 'bin', 'bash.exe');
 }
 /**
  * Apply the per-agent Tier 0 shell override for one agent, per
@@ -609,35 +791,33 @@ function recordShellFixState(results, bashExe, statePath) {
  */
 export function fixShellConfiguration(_baseDir = '.', agents = [...AGENT_KEYS], complex = process.stdin.isTTY === true, statePath = shellFixStatePath()) {
     if (process.platform === 'win32') {
+        // No early return when agentenv itself runs in Git Bash: the fix targets
+        // each agent's own shell config, which doesn't depend on the shell
+        // agentenv was launched from (see checkAgentShellConfiguration).
         const shellInfo = detectShell();
-        if (shellInfo.isPosixCompatible) {
-            return {
-                success: true,
-                message: 'Shell is already POSIX-compatible',
-                gitBashPath: shellInfo.gitBashPath,
-            };
-        }
         if (!shellInfo.gitBashPath) {
             return {
                 success: true,
-                message: 'Git Bash not found on PATH; install Git for Windows to enable Tier 0 shell fixes',
+                message: 'Git Bash not found in common install locations or on PATH; install Git for Windows to enable Tier 0 shell fixes',
             };
         }
-        // Non-TTY/test shell: skip file writes, just report the state
+        // Non-TTY/test shell, or tier0.mode = "never": skip file writes, just
+        // report the state. (Callers already prefix messages with "Tier 0: "
+        // themselves, so this string must not repeat it.)
         if (!complex) {
             return {
                 success: true,
-                message: `Tier 0: checked; would fix ${agents.length} agent shell(s) in an interactive terminal — skipped (non-TTY)`,
+                message: `checked; would fix ${agents.length} agent shell(s) — skipped (pass --shell-fix always, or run interactively, to apply)`,
                 gitBashPath: shellInfo.gitBashPath,
             };
         }
         const bashExe = bashExecutable(shellInfo.gitBashPath);
-        const home = process.env.HOME || process.env.USERPROFILE || '';
+        const home = homeDir();
         const results = agents.map((agent) => applyAgentShellFix(agent, bashExe, home));
         const written = results.filter((result) => result.action === 'created' || result.action === 'updated');
         recordShellFixState(written, bashExe, statePath);
         const message = written.length > 0
-            ? `Current shell (${shellInfo.currentShell}) is not POSIX-compatible; pointed agents at Git Bash (${bashExe})`
+            ? `pointed ${written.length} agent shell(s) at Git Bash (${bashExe})`
             : `Git Bash detected at ${bashExe}; agent shell config already up to date`;
         return {
             success: true,
@@ -692,16 +872,16 @@ export function fixShellConfiguration(_baseDir = '.', agents = [...AGENT_KEYS],
  * since that's the interactive shell the user is running agentenv from, not
  * the target agent's configuration.
  */
-export function checkAgentShellConfiguration(agent, home = process.env.HOME || process.env.USERPROFILE || '') {
+export function checkAgentShellConfiguration(agent, home = homeDir(), exists = fs.existsSync) {
     switch (agent) {
         case 'claude_code':
-            return checkClaudeCodeShell(home);
+            return checkClaudeCodeShell(home, exists);
         case 'codex_cli':
-            return checkCodexShell(home);
+            return checkCodexShell(home, exists);
         case 'copilot':
             return checkCopilotShell();
         case 'opencode':
-            return checkOpenCodeShell(home);
+            return checkOpenCodeShell(home, exists);
         case 'gemini_cli':
         case 'cursor':
         case 'windsurf':
@@ -713,11 +893,19 @@ export function checkAgentShellConfiguration(agent, home = process.env.HOME || p
 function isBashPath(value) {
     return typeof value === 'string' && value.length > 0;
 }
+/**
+ * A configured shell still needs the Tier 0 fix when it isn't bash at all, or
+ * when it is Git's raw MSYS bash and the launcher exists to replace it (see
+ * preferredGitBashLauncher) — the same value bashExecutable() would write.
+ */
+function shellNeedsFix(shell, exists) {
+    return (!shell.toLowerCase().includes('bash') || preferredGitBashLauncher(shell, exists) !== undefined);
+}
 /**
  * Check Claude Code shell configuration: reads env.CLAUDE_CODE_GIT_BASH_PATH,
  * the exact field patchClaudeShellFix writes.
  */
-function checkClaudeCodeShell(home) {
+function checkClaudeCodeShell(home, exists) {
     try {
         const settingsPath = path.join(home, '.claude', 'settings.json');
         if (fs.existsSync(settingsPath)) {
@@ -728,7 +916,7 @@ function checkClaudeCodeShell(home) {
                 return {
                     isConfigured: true,
                     shell: bashPath,
-                    needsFix: !bashPath.toLowerCase().includes('bash'),
+                    needsFix: shellNeedsFix(bashPath, exists),
                 };
             }
         }
@@ -771,7 +959,7 @@ function readTomlWindowsShellPath(content) {
  * Check Codex CLI shell configuration: reads [windows] shell_path from
  * config.toml, the exact field patchCodexShellFix writes.
  */
-function checkCodexShell(home) {
+function checkCodexShell(home, exists) {
     try {
         const configPath = path.join(home, '.codex', 'config.toml');
         if (fs.existsSync(configPath)) {
@@ -780,7 +968,7 @@ function checkCodexShell(home) {
                 return {
                     isConfigured: true,
                     shell: shellPath,
-                    needsFix: !shellPath.toLowerCase().includes('bash'),
+                    needsFix: shellNeedsFix(shellPath, exists),
                 };
             }
         }
@@ -802,14 +990,14 @@ function checkCopilotShell() {
  * Check OpenCode shell configuration: reads `shell`, the exact field
  * patchOpenCodeShellFix writes.
  */
-function checkOpenCodeShell(home) {
+function checkOpenCodeShell(home, exists) {
     try {
         const configPath = path.join(home, '.config', 'opencode', 'opencode.json');
         if (fs.existsSync(configPath)) {
             const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
             const shell = config.shell;
             if (isBashPath(shell)) {
-                return { isConfigured: true, shell, needsFix: !shell.toLowerCase().includes('bash') };
+                return { isConfigured: true, shell, needsFix: shellNeedsFix(shell, exists) };
             }
         }
         return { isConfigured: false, needsFix: true };