sema-core 1.0.14 → 2.0.1

package/dist/util/shell.js

@@ -36,8 +36,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PersistentShell = void 0;
-exports.formatDuration = formatDuration;
+exports.STDERR_HEAD_TAIL_LINES = exports.STDOUT_HEAD_TAIL_LINES = exports.PersistentShell = void 0;
+exports.humanizeDuration = humanizeDuration;
+exports.getShellRuntimeInfo = getShellRuntimeInfo;
+exports.toOneShotShell = toOneShotShell;
+exports.getOneShotShellRuntimeInfo = getOneShotShellRuntimeInfo;
+exports.formatOutput = formatOutput;
 const fs = __importStar(require("fs"));
 const fs_1 = require("fs");
 const shell_quote_1 = __importDefault(require("shell-quote"));
@@ -48,10 +52,11 @@ const crypto = __importStar(require("crypto"));
 const iconv = __importStar(require("iconv-lite"));
 const log_1 = require("./log");
 const platform_1 = require("./platform");
+const cwd_1 = require("./cwd");
 // 临时文件前缀
 const TEMPFILE_PREFIX = (0, path_1.join)(os.tmpdir(), 'sema-');
 // 默认超时时间（2分钟）
-const DEFAULT_TIMEOUT = 120 * 1000;
+const DEFAULT_SHELL_TIMEOUT = 120 * 1000;
 // SIGTERM信号的标准退出码
 const SIGTERM_CODE = 143;
 // 流式输出检查间隔（ms）
@@ -63,7 +68,7 @@ const FILE_SUFFIXES = {
     STDERR: '-stderr', // 标准错误文件后缀
     CWD: '-cwd', // 当前工作目录文件后缀
 };
-function formatDuration(ms) {
+function humanizeDuration(ms) {
     const s = Math.round(ms / 1000);
     if (s < 60)
         return `${s}s`;
@@ -116,298 +121,223 @@ function filterCygwinNoise(text) {
         .filter(line => !CYGWIN_NOISE_RE.test(line))
         .join('\n');
 }
-// Shell配置文件映射
-const SHELL_CONFIGS = {
-    '/bin/bash': '.bashrc',
-    '/bin/zsh': '.zshrc',
-};
 // 为Bash转义字符串
 function quoteForBash(str) {
     return `'${str.replace(/'/g, "'\\''")}'`;
 }
-// 检查文件是否存在
-function fileExists(p) {
-    return !!p && (0, fs_1.existsSync)(p);
-}
-// testBashAvailability 结果缓存，避免对同一路径重复测试
-const bashTestCache = new Map();
-// 测试 bash 是否可用
-function testBashAvailability(bashPath, type = 'msys') {
-    const cacheKey = `${bashPath}:${type}`;
-    const cached = bashTestCache.get(cacheKey);
-    if (cached !== undefined)
-        return cached;
-    const saveAndReturn = (result) => {
-        bashTestCache.set(cacheKey, result);
-        return result;
-    };
-    try {
-        (0, log_1.logInfo)(`测试 bash 可用性: ${bashPath}`);
-        const testCommand = `"${bashPath}" -c "echo SEMA_TEST_OK"`;
-        const result = (0, child_process_1.execSync)(testCommand, {
-            stdio: 'pipe',
-            timeout: 3000,
-            encoding: 'utf8'
-        });
-        const output = result.toString().trim();
-        if (output.includes('SEMA_TEST_OK')) {
-            (0, log_1.logInfo)(`✅ bash 测试通过: ${bashPath}`);
-            return saveAndReturn(true);
+// 测试 bash 是否可用（结果自动缓存）
+const testBashAvailability = (() => {
+    const cache = new Map();
+    return (bashPath, type = 'msys') => {
+        const cacheKey = `${bashPath}:${type}`;
+        const cached = cache.get(cacheKey);
+        if (cached !== undefined)
+            return cached;
+        let ok = false;
+        try {
+            (0, log_1.logInfo)(`测试 bash 可用性: ${bashPath}`);
+            const output = (0, child_process_1.execSync)(`"${bashPath}" -c "echo SEMA_TEST_OK"`, {
+                stdio: 'pipe', timeout: 3000, encoding: 'utf8',
+            }).toString().trim();
+            ok = output.includes('SEMA_TEST_OK');
+            if (ok)
+                (0, log_1.logInfo)(`bash 测试通过: ${bashPath}`);
+            else
+                (0, log_1.logWarn)(`bash 测试失败，输出不符合预期: ${bashPath}, 输出: ${output}`);
         }
-        else {
-            (0, log_1.logWarn)(`❌ bash 测试失败，输出不符合预期: ${bashPath}, 输出: ${output}`);
-            return saveAndReturn(false);
+        catch (error) {
+            (0, log_1.logWarn)(`bash 测试失败: ${bashPath}, 错误: ${error}`);
         }
-    }
-    catch (error) {
-        (0, log_1.logWarn)(`❌ bash 测试失败: ${bashPath}, 错误: ${error}`);
-        return saveAndReturn(false);
-    }
-}
-// 判断路径是否为 Git Bash
-function isGitBashPath(p) {
-    const lower = p.toLowerCase();
-    return lower.includes('git') || lower.includes('git for windows');
+        cache.set(cacheKey, ok);
+        return ok;
+    };
+})();
+// 尝试使用指定路径的 bash，存在且测试通过返回 true
+function tryBash(candidate, type = 'msys') {
+    return (0, fs_1.existsSync)(candidate) && testBashAvailability(candidate, type);
 }
 // 检测可用的Shell（结果缓存，避免重复探测）
 let detectedShellCache = null;
-function detectShell() {
-    if (detectedShellCache)
-        return detectedShellCache;
-    detectedShellCache = detectShellImpl();
-    return detectedShellCache;
+function resolveShellBinary() {
+    return (detectedShellCache ??= detectShellImpl());
 }
-function detectShellImpl() {
-    if (!platform_1.IS_WIN) {
-        const bin = process.env.SHELL || '/bin/bash';
-        return { bin, args: ['-l'], type: 'posix' };
+function getShellRuntimeInfo() {
+    try {
+        const { bin, args, type } = resolveShellBinary();
+        return { bin, args, type };
     }
-    (0, log_1.logInfo)('开始检测 Windows Shell 环境...');
-    // Windows 平台 Shell 检测逻辑 - 优化后的检测顺序
-    // 1) 显式环境变量优先级最高 (支持 SEMA_BASH 环境变量)
-    if (process.env.SEMA_BASH && (0, fs_1.existsSync)(process.env.SEMA_BASH)) {
-        if (testBashAvailability(process.env.SEMA_BASH)) {
-            (0, log_1.logInfo)(`使用 SEMA_BASH 环境变量指定的 bash: ${process.env.SEMA_BASH}`);
-            return { bin: process.env.SEMA_BASH, args: ['-l'], type: 'msys' };
-        }
-        else {
-            (0, log_1.logWarn)(`SEMA_BASH 指定的 bash 测试失败: ${process.env.SEMA_BASH}`);
-        }
+    catch {
+        return null;
     }
-    // 1.1) 如果SHELL环境变量指向存在的bash.exe，则测试并使用它
-    if (process.env.SHELL && /bash\.exe$/i.test(process.env.SHELL) && (0, fs_1.existsSync)(process.env.SHELL)) {
-        // 对 System32 bash 进行特殊测试
-        const isSystem32Bash = process.env.SHELL.toLowerCase().includes('system32');
-        const testType = isSystem32Bash ? 'wsl' : 'msys';
-        if (testBashAvailability(process.env.SHELL, testType)) {
-            (0, log_1.logInfo)(`使用 SHELL 环境变量指定的 bash: ${process.env.SHELL}`);
-            return { bin: process.env.SHELL, args: ['-l'], type: isSystem32Bash ? 'wsl' : 'msys' };
-        }
-        else {
-            (0, log_1.logWarn)(`SHELL 环境变量指定的 bash 测试失败: ${process.env.SHELL}`);
-        }
+}
+function toOneShotShell(shell) {
+    switch (shell.type) {
+        case 'posix':
+        case 'msys':
+            return { bin: shell.bin, args: ['-c'], type: shell.type };
+        case 'wsl':
+            return { bin: shell.bin, args: ['-e', 'bash', '-c'], type: shell.type };
+        case 'powershell':
+            return { bin: shell.bin, args: ['-NoProfile', '-Command'], type: shell.type };
+        case 'cmd':
+            return { bin: shell.bin, args: ['/c'], type: shell.type };
     }
-    // 2) 优先在PATH中搜索bash.exe (提前到这里，覆盖更多安装方式)
-    (0, log_1.logInfo)('在 PATH 中搜索 bash.exe...');
-    // 在Windows上尝试多种PATH环境变量形式
+}
+function getOneShotShellRuntimeInfo() {
+    return toOneShotShell(resolveShellBinary());
+}
+// 从环境变量检测 bash（SEMA_BASH / SHELL）
+function detectBashFromEnv() {
+    // SEMA_BASH 环境变量优先级最高
+    if (process.env.SEMA_BASH && tryBash(process.env.SEMA_BASH)) {
+        (0, log_1.logInfo)(`使用 SEMA_BASH 环境变量指定的 bash: ${process.env.SEMA_BASH}`);
+        return { bin: process.env.SEMA_BASH, args: ['-l'], type: 'msys' };
+    }
+    // SHELL 环境变量指向 bash.exe
+    const shell = process.env.SHELL;
+    if (shell && /bash\.exe$/i.test(shell) && (0, fs_1.existsSync)(shell)) {
+        const isSystem32 = shell.toLowerCase().includes('system32');
+        const type = isSystem32 ? 'wsl' : 'msys';
+        if (testBashAvailability(shell, type)) {
+            (0, log_1.logInfo)(`使用 SHELL 环境变量指定的 bash: ${shell}`);
+            return { bin: shell, args: ['-l'], type };
+        }
+    }
+    return null;
+}
+// 获取 Windows PATH 条目
+function getWindowsPathEntries() {
     let pathEnv = process.env.PATH || process.env.Path || process.env.path || '';
-    // 如果还是空的，尝试遍历所有环境变量找到PATH
+    // 遍历所有环境变量找 PATH（Windows 大小写不敏感）
     if (!pathEnv) {
         for (const [key, value] of Object.entries(process.env)) {
             if (key.toLowerCase() === 'path' && value) {
                 pathEnv = value;
-                (0, log_1.logInfo)(`找到 PATH 环境变量 (${key}): ${value.substring(0, 100)}...`);
                 break;
             }
         }
     }
-    if (platform_1.IS_WIN && pathEnv && pathEnv.length < 500) {
+    // PATH 看起来不完整时从 PowerShell 补充
+    if (pathEnv && pathEnv.length < 500) {
         try {
-            (0, log_1.logInfo)('PATH看起来不完整，尝试从PowerShell重新获取...');
             const fullPath = (0, child_process_1.execSync)('powershell.exe -Command "$env:PATH"', {
-                encoding: 'utf8',
-                timeout: 5000
+                encoding: 'utf8', timeout: 5000,
             }).trim();
-            if (fullPath && fullPath.length > pathEnv.length) {
-                (0, log_1.logInfo)(`从PowerShell获取到更完整的PATH (${fullPath.length} vs ${pathEnv.length} 字符)`);
+            if (fullPath.length > pathEnv.length)
                 pathEnv = fullPath;
-            }
         }
-        catch (error) {
-            (0, log_1.logWarn)(`无法从PowerShell获取PATH: ${error}`);
-        }
-    }
-    (0, log_1.logInfo)(`PATH 环境变量内容: ${pathEnv ? pathEnv.substring(0, 200) + '...' : '(空)'}`);
-    const pathEntries = (0, platform_1.splitPathEntries)(pathEnv);
-    (0, log_1.logInfo)(`解析出的 PATH 条目数量: ${pathEntries.length}`);
-    // 打印前几个路径条目用于调试
-    pathEntries.slice(0, 5).forEach((entry, index) => {
-        (0, log_1.logInfo)(`PATH[${index}]: ${entry}`);
-    });
-    // 2.1) 首先优先处理PATH中的Git Bash
-    (0, log_1.logInfo)('优先检查 PATH 中的 Git Bash...');
+        catch { /* ignore */ }
+    }
+    return (0, platform_1.splitPathEntries)(pathEnv);
+}
+// 在 PATH 中搜索 bash.exe（Git Bash 优先）
+function detectBashInPath(pathEntries) {
+    // 单次遍历，Git Bash 优先收集，非 Git Bash 延后
+    const nonGitCandidates = [];
     for (const p of pathEntries) {
         const candidate = (0, path_1.join)(p, 'bash.exe');
-        (0, log_1.logInfo)(`检查路径: ${candidate}`);
         if ((0, fs_1.existsSync)(candidate)) {
-            // 检查是否为Git Bash路径 - 更宽泛的检测
-            const isGitBash = isGitBashPath(candidate);
-            (0, log_1.logInfo)(`发现 bash.exe: ${candidate}, 是否Git Bash: ${isGitBash}`);
-            if (isGitBash) {
-                if (testBashAvailability(candidate, 'msys')) {
-                    (0, log_1.logInfo)(`在 PATH 中找到可用的 Git Bash: ${candidate}`);
+            const lower = candidate.toLowerCase();
+            if (lower.includes('git') || lower.includes('git for windows')) {
+                if (tryBash(candidate, 'msys'))
                     return { bin: candidate, args: ['-l'], type: 'msys' };
-                }
-                else {
-                    (0, log_1.logWarn)(`PATH 中的 Git Bash 测试失败，跳过: ${candidate}`);
-                }
+            }
+            else {
+                nonGitCandidates.push(candidate);
             }
         }
         else {
-            // 如果是Git的cmd目录，检查对应的bin目录和usr/bin目录
+            // Git cmd 目录 → 推断 bin 目录
             const pLower = p.toLowerCase();
             if (pLower.includes('git') && (pLower.endsWith('cmd') || pLower.endsWith('cmd\\'))) {
-                (0, log_1.logInfo)(`检测到Git cmd目录: ${p}，尝试查找对应的bin目录`);
-                // 尝试多个可能的bin目录位置
                 const gitRoot = p.replace(/[\\\/]cmd[\\\/]?$/i, '');
-                const binCandidates = [
-                    (0, path_1.join)(gitRoot, 'bin', 'bash.exe'),
-                    (0, path_1.join)(gitRoot, 'usr', 'bin', 'bash.exe'),
-                    (0, path_1.join)(gitRoot, 'mingw64', 'bin', 'bash.exe')
-                ];
-                for (const binCandidate of binCandidates) {
-                    (0, log_1.logInfo)(`尝试Git Bash路径: ${binCandidate}`);
-                    if ((0, fs_1.existsSync)(binCandidate)) {
-                        (0, log_1.logInfo)(`发现 bash.exe: ${binCandidate}, 是否Git Bash: true`);
-                        if (testBashAvailability(binCandidate, 'msys')) {
-                            (0, log_1.logInfo)(`在 PATH 中找到可用的 Git Bash (通过cmd->bin映射): ${binCandidate}`);
-                            return { bin: binCandidate, args: ['-l'], type: 'msys' };
-                        }
-                        else {
-                            (0, log_1.logWarn)(`Git Bash 测试失败，跳过: ${binCandidate}`);
-                        }
-                    }
+                for (const sub of ['bin', 'usr/bin', 'mingw64/bin']) {
+                    const c = (0, path_1.join)(gitRoot, sub, 'bash.exe');
+                    if (tryBash(c, 'msys'))
+                        return { bin: c, args: ['-l'], type: 'msys' };
                 }
             }
         }
     }
-    // 2.2) 然后处理PATH中的其他bash
-    (0, log_1.logInfo)('检查 PATH 中的其他 bash...');
-    for (const p of pathEntries) {
-        const candidate = (0, path_1.join)(p, 'bash.exe');
-        if ((0, fs_1.existsSync)(candidate)) {
-            // 跳过已经处理过的Git Bash
-            if (!isGitBashPath(candidate)) {
-                // 对所有找到的 bash 进行测试验证
-                const isSystem32Bash = candidate.toLowerCase().includes('system32');
-                const testType = isSystem32Bash ? 'wsl' : 'msys';
-                if (testBashAvailability(candidate, testType)) {
-                    (0, log_1.logInfo)(`在 PATH 中找到可用的 bash: ${candidate}`);
-                    return { bin: candidate, args: ['-l'], type: isSystem32Bash ? 'wsl' : 'msys' };
-                }
-                else {
-                    (0, log_1.logWarn)(`PATH 中的 bash 测试失败，跳过: ${candidate}`);
-                }
-            }
-        }
+    // 非 Git Bash 候选
+    for (const candidate of nonGitCandidates) {
+        const isSystem32 = candidate.toLowerCase().includes('system32');
+        const type = isSystem32 ? 'wsl' : 'msys';
+        if (testBashAvailability(candidate, type))
+            return { bin: candidate, args: ['-l'], type };
     }
-    // 3) 检测 Git Bash 的常见固定位置 (作为 PATH 搜索的补充)
-    (0, log_1.logInfo)('搜索 Git Bash 固定安装位置...');
+    return null;
+}
+// 在固定安装位置搜索 Git Bash / MSYS2
+function detectBashInFixedLocations() {
     const programFiles = [
         process.env['ProgramFiles'],
         process.env['ProgramFiles(x86)'],
         process.env['ProgramW6432'],
     ].filter(Boolean);
-    const localAppData = process.env['LocalAppData'];
-    const gitBashCandidates = [];
-    // Git for Windows 标准安装位置
+    const candidates = [];
     for (const base of programFiles) {
-        gitBashCandidates.push((0, path_1.join)(base, 'Git', 'bin', 'bash.exe'), (0, path_1.join)(base, 'Git', 'usr', 'bin', 'bash.exe'));
+        candidates.push((0, path_1.join)(base, 'Git', 'bin', 'bash.exe'), (0, path_1.join)(base, 'Git', 'usr', 'bin', 'bash.exe'));
     }
-    // 用户级安装位置
+    const localAppData = process.env['LocalAppData'];
     if (localAppData) {
-        gitBashCandidates.push((0, path_1.join)(localAppData, 'Programs', 'Git', 'bin', 'bash.exe'), (0, path_1.join)(localAppData, 'Programs', 'Git', 'usr', 'bin', 'bash.exe'));
+        candidates.push((0, path_1.join)(localAppData, 'Programs', 'Git', 'bin', 'bash.exe'), (0, path_1.join)(localAppData, 'Programs', 'Git', 'usr', 'bin', 'bash.exe'));
     }
-    // 检查 Git Bash 候选位置
-    for (const candidate of gitBashCandidates) {
-        if ((0, fs_1.existsSync)(candidate)) {
-            if (testBashAvailability(candidate)) {
-                (0, log_1.logInfo)(`找到 Git Bash: ${candidate}`);
-                return { bin: candidate, args: ['-l'], type: 'msys' };
-            }
-            else {
-                (0, log_1.logWarn)(`Git Bash 测试失败，跳过: ${candidate}`);
-            }
-        }
-    }
-    // 3.1) MSYS2 位置
-    const msys2Candidates = [
-        'C:/msys64/usr/bin/bash.exe',
-        'C:/msys32/usr/bin/bash.exe',
-    ];
-    for (const candidate of msys2Candidates) {
-        if ((0, fs_1.existsSync)(candidate)) {
-            if (testBashAvailability(candidate)) {
-                (0, log_1.logInfo)(`找到 MSYS2 bash: ${candidate}`);
-                return { bin: candidate, args: ['-l'], type: 'msys' };
-            }
-            else {
-                (0, log_1.logWarn)(`MSYS2 bash 测试失败，跳过: ${candidate}`);
-            }
-        }
+    // MSYS2
+    candidates.push('C:/msys64/usr/bin/bash.exe', 'C:/msys32/usr/bin/bash.exe');
+    for (const candidate of candidates) {
+        if (tryBash(candidate))
+            return { bin: candidate, args: ['-l'], type: 'msys' };
     }
-    // 4) 尝试 WSL (仅当明确可用时)
-    (0, log_1.logInfo)('检测 WSL 环境...');
+    return null;
+}
+// 检测 WSL
+function detectWsl() {
     try {
-        // 快速探测确保WSL+bash存在且可用
         (0, child_process_1.execSync)('wsl.exe -e bash -lc "echo SEMA_OK"', { stdio: 'ignore', timeout: 2000 });
         (0, log_1.logInfo)('WSL bash 可用');
         return { bin: 'wsl.exe', args: ['-e', 'bash', '-l'], type: 'wsl' };
     }
-    catch (error) {
-        (0, log_1.logWarn)(`WSL 检测失败: ${error}`);
-    }
-    // 5) 回退到 PowerShell (Windows 现代 Shell)
-    (0, log_1.logInfo)('尝试使用 PowerShell 作为回退方案...');
-    const powershellCandidates = [
-        'pwsh.exe', // PowerShell 7+
-        'powershell.exe', // Windows PowerShell 5.x
-    ];
-    for (const psCandidate of powershellCandidates) {
+    catch {
+        return null;
+    }
+}
+// 检测 PowerShell / cmd.exe 回退
+function detectFallbackShell() {
+    // PowerShell
+    for (const ps of ['pwsh.exe', 'powershell.exe']) {
         try {
-            // 测试 PowerShell 是否可用
-            // 修复: 增加超时时间，使用NoProfile参数，验证输出
-            const result = (0, child_process_1.execSync)(`${psCandidate} -NoProfile -Command "Write-Output 'SEMA_PS_OK'"`, {
-                stdio: 'pipe',
-                timeout: 3000, // 从1000ms增加到3000ms
-                encoding: 'utf8'
+            const result = (0, child_process_1.execSync)(`${ps} -NoProfile -Command "Write-Output 'SEMA_PS_OK'"`, {
+                stdio: 'pipe', timeout: 3000, encoding: 'utf8',
             });
-            // 验证输出内容
             if (result.toString().trim().includes('SEMA_PS_OK')) {
-                (0, log_1.logInfo)(`使用 PowerShell: ${psCandidate}`);
-                return { bin: psCandidate, args: ['-NoProfile', '-Command'], type: 'powershell' };
-            }
-            else {
-                (0, log_1.logWarn)(`PowerShell ${psCandidate} 测试输出不符合预期: ${result.toString().trim()}`);
+                (0, log_1.logInfo)(`使用 PowerShell: ${ps}`);
+                return { bin: ps, args: ['-NoProfile', '-Command'], type: 'powershell' };
             }
         }
-        catch (error) {
-            (0, log_1.logWarn)(`PowerShell ${psCandidate} 不可用: ${error}`);
-        }
+        catch { /* ignore */ }
     }
-    // 6) 最后回退到 cmd.exe
-    (0, log_1.logWarn)('回退到 Windows 命令提示符 (cmd.exe)');
-    try {
-        const comspec = process.env.ComSpec || 'cmd.exe';
-        if ((0, fs_1.existsSync)(comspec)) {
-            (0, log_1.logInfo)(`使用 cmd.exe: ${comspec}`);
-            return { bin: comspec, args: ['/k'], type: 'cmd' };
-        }
+    // cmd.exe
+    const comspec = process.env.ComSpec || 'cmd.exe';
+    if ((0, fs_1.existsSync)(comspec)) {
+        (0, log_1.logInfo)(`使用 cmd.exe: ${comspec}`);
+        return { bin: comspec, args: ['/k'], type: 'cmd' };
     }
-    catch (error) {
-        (0, log_1.logError)(`cmd.exe 检测失败: ${error}`);
+    return null;
+}
+function detectShellImpl() {
+    if (!platform_1.IS_WIN) {
+        return { bin: process.env.SHELL || '/bin/bash', args: ['-l'], type: 'posix' };
     }
-    // 7) 最后的手段：提供详细的错误信息和建议
+    (0, log_1.logInfo)('开始检测 Windows Shell 环境...');
+    // 按优先级依次尝试
+    const result = detectBashFromEnv() ??
+        detectBashInPath(getWindowsPathEntries()) ??
+        detectBashInFixedLocations() ??
+        detectWsl() ??
+        detectFallbackShell();
+    if (result)
+        return result;
     const hint = [
         '无法找到任何可用的 Shell 环境！',
         '',
@@ -431,7 +361,7 @@ class PersistentShell {
         this._exitCachedStdout = ''; // shell退出时缓存的stdout（防竞态）
         this._exitCachedStderr = ''; // shell退出时缓存的stderr（防竞态）
         // 检测可用的Shell
-        const { bin, args, type } = detectShell();
+        const { bin, args, type } = resolveShellBinary();
         this.binShell = bin;
         this.shellArgs = args;
         this.shellType = type;
@@ -451,7 +381,6 @@ class PersistentShell {
         // 监听Shell退出事件
         this.shell.on('exit', (code, signal) => {
             if (code) {
-                // TODO: 最好能通知用户Shell崩溃了
                 (0, log_1.logError)(`Shell exited with code ${code} and signal ${signal}`);
             }
             // 在删除文件前缓存内容，防止与 exec_() 的 readOutput() 产生竞态条件
@@ -517,7 +446,7 @@ class PersistentShell {
     // 获取单例实例
     static getInstance() {
         if (!PersistentShell.instance || !PersistentShell.instance.isAlive) {
-            const cwd = PersistentShell.instance?.cwd || process.cwd();
+            const cwd = PersistentShell.instance?.cwd || (0, cwd_1.readInitialCwd)();
             PersistentShell.instance = new PersistentShell(cwd);
         }
         return PersistentShell.instance;
@@ -631,85 +560,56 @@ class PersistentShell {
             this.processQueue();
         });
     }
-    // 执行命令（内部实现）
-    async exec_(command, timeout, onChunk, onTimeout) {
-        /**
-         * 直接执行命令，不经过队列。
-         * 并发不变性：
-         * - 不适合并发调用（使用共享文件）
-         * - 仅在队列空闲时调用
-         * - 依赖基于文件的IPC处理Shell交互
-         * - 不修改命令队列状态
-         * - 通过commandInterrupted标志跟踪中断状态
-         * - 在新命令开始时重置中断状态
-         * - 在结果对象中报告中断状态
-         *
-         * 超时机制：
-         * - idle timeout: ${IDLE_TIMEOUT_MS/1000}秒无新输出 → kill（每次有输出变化则重置）
-         * - max timeout: min(用户传入 timeout, 3min) → kill（从命令开始倒计时，不重置）
-         * - 谁先触发谁 kill，超时后仍返回已写入临时文件的部分输出
-         *
-         * 退出码和CWD处理：
-         * - 执行命令并立即将其退出码捕获到Shell变量中
-         * - 捕获退出码后更新CWD文件的工作目录
-         * - 将保存的退出码作为最后一步写入状态文件
-         * - 此序列消除了退出码捕获和CWD更新之间的竞争条件
-         * - pwd()方法直接读取CWD文件获取当前目录信息
-         */
-        // 如果是非 bash Shell，需要特殊处理
-        if (this.shellType === 'cmd' || this.shellType === 'powershell') {
-            return this.execNonBashShell(command, timeout, onChunk);
-        }
-        const quotedCommand = shell_quote_1.default.quote([command]);
-        // 检查命令语法（语法错误提前返回，避免污染 shell 状态）
-        // Windows 上 spawn 子进程较慢，使用更长超时
+    /**
+     * 检查命令语法（语法错误提前返回，避免污染 shell 状态）
+     * 返回 null 表示语法正常，返回 ShellExecResult 表示语法错误
+     */
+    checkSyntax(command, quotedCommand) {
         const syntaxCheckTimeout = platform_1.IS_WIN ? 5000 : 1000;
         try {
             if (this.shellType === 'wsl') {
                 (0, child_process_1.execSync)(`wsl.exe -e bash -n -c ${quotedCommand}`, {
-                    stdio: 'ignore',
-                    timeout: syntaxCheckTimeout,
+                    stdio: 'ignore', timeout: syntaxCheckTimeout,
                 });
             }
             else if (platform_1.IS_WIN) {
-                // 在 Windows 上使用 spawn 方式直接调用 bash，避免 cmd.exe 对引号的错误解析
                 const { spawnSync } = require('child_process');
                 const result = spawnSync(this.binShell, ['-n', '-c', command], {
-                    stdio: 'ignore',
-                    timeout: syntaxCheckTimeout,
-                    windowsHide: true,
+                    stdio: 'ignore', timeout: syntaxCheckTimeout, windowsHide: true,
                 });
-                // 检查是否有错误，统一抛出让 catch 处理
                 if (result.status !== 0 || result.error) {
                     throw result.error || new Error(`Syntax check failed with exit code ${result.status}`);
                 }
             }
             else {
-                // Unix 系统使用 execSync
                 (0, child_process_1.execSync)(`${this.binShell} -n -c ${quotedCommand}`, {
-                    stdio: 'ignore',
-                    timeout: syntaxCheckTimeout,
+                    stdio: 'ignore', timeout: syntaxCheckTimeout,
                 });
             }
         }
         catch (err) {
-            // 超时（ETIMEDOUT）说明无法完成语法检查，不等于语法错误，继续执行
             const isTimeout = err?.code === 'ETIMEDOUT' || err?.killed === true;
             if (isTimeout) {
                 (0, log_1.logWarn)(`语法检查超时，跳过并继续执行命令: ${command}`);
             }
             else {
-                // 真正的语法错误，提前返回
-                const errorStr = typeof err === 'string' ? err : String(err || '');
-                return Promise.resolve({
-                    stdout: '',
-                    stderr: errorStr,
-                    code: 128,
-                    interrupted: false,
-                });
+                return { stdout: '', stderr: String(err || ''), code: 128, interrupted: false };
             }
         }
-        const maxTimeout = timeout || DEFAULT_TIMEOUT;
+        return null;
+    }
+    // 执行命令（内部实现）
+    async exec_(command, timeout, onChunk, onTimeout) {
+        // 非 bash Shell 走单独路径
+        if (this.shellType === 'cmd' || this.shellType === 'powershell') {
+            return this.execNonBashShell(command, timeout, onChunk);
+        }
+        const quotedCommand = shell_quote_1.default.quote([command]);
+        // 语法检查
+        const syntaxError = this.checkSyntax(command, quotedCommand);
+        if (syntaxError)
+            return syntaxError;
+        const maxTimeout = timeout || DEFAULT_SHELL_TIMEOUT;
         // 为新命令重置中断状态
         this.commandInterrupted = false;
         return new Promise(resolve => {
@@ -720,7 +620,8 @@ class PersistentShell {
             // 使用命令数组清晰地分解命令序列
             const commandParts = [];
             // 1. 重定向执行主命令，cd/export 等状态变更在命令间持久化
-            commandParts.push(`eval ${quotedCommand} < /dev/null > ${quoteForBash(this.stdoutFileBashPath)} 2> ${quoteForBash(this.stderrFileBashPath)}`);
+            // 注意：使用 <&- 关闭 stdin 而非 < /dev/null，以避免 Windows 下创建 nul 文件
+            commandParts.push(`eval ${quotedCommand} <&- > ${quoteForBash(this.stdoutFileBashPath)} 2> ${quoteForBash(this.stderrFileBashPath)}`);
             // 2. 命令执行后立即捕获退出码，避免丢失
             commandParts.push(`EXEC_EXIT_CODE=$?`);
             // 3. 更新CWD文件
@@ -825,7 +726,7 @@ class PersistentShell {
                             const { stdout, stderr } = readOutput();
                             finish({
                                 stdout,
-                                stderr: (stderr ? stderr + '\n' : '') + `(timeout ${formatDuration(maxTimeout)})`,
+                                stderr: (stderr ? stderr + '\n' : '') + `(timeout ${humanizeDuration(maxTimeout)})`,
                                 code: SIGTERM_CODE,
                                 interrupted: this.commandInterrupted,
                             });
@@ -853,7 +754,7 @@ class PersistentShell {
     }
     // 非 Bash Shell 特殊处理 (PowerShell, cmd.exe)
     async execNonBashShell(command, timeout, onChunk) {
-        const commandTimeout = timeout || DEFAULT_TIMEOUT;
+        const commandTimeout = timeout || DEFAULT_SHELL_TIMEOUT;
         this.commandInterrupted = false;
         return new Promise(resolve => {
             try {
@@ -903,7 +804,7 @@ class PersistentShell {
                         childProcess.kill('SIGTERM');
                         resolve({
                             stdout,
-                            stderr: stderr + `\n(timeout ${formatDuration(commandTimeout)})`,
+                            stderr: stderr + `\n(timeout ${humanizeDuration(commandTimeout)})`,
                             code: SIGTERM_CODE,
                             interrupted: true,
                         });
@@ -1000,4 +901,31 @@ class PersistentShell {
 exports.PersistentShell = PersistentShell;
 // 单例实例
 PersistentShell.instance = null;
+// ==================== 输出格式化 ====================
+exports.STDOUT_HEAD_TAIL_LINES = 500;
+exports.STDERR_HEAD_TAIL_LINES = 50;
+const MAX_LINE_LENGTH = 2000;
+function truncateLines(lines) {
+    return lines.map(l => l.length > MAX_LINE_LENGTH ? l.slice(0, MAX_LINE_LENGTH) + '...[line truncated]' : l);
+}
+function formatOutput(content, headTailLines = exports.STDOUT_HEAD_TAIL_LINES, { resolveCR = true } = {}) {
+    // 处理 \r（回车符）：模拟终端行为，只保留每行最后一次 \r 后的内容
+    const resolved = resolveCR
+        ? content.split('\n').map(line => {
+            if (!line.includes('\r'))
+                return line;
+            const parts = line.split('\r');
+            return parts[parts.length - 1];
+        }).join('\n')
+        : content;
+    const lines = truncateLines(resolved.split('\n'));
+    const totalLines = lines.length;
+    const skipped = totalLines - headTailLines * 2;
+    return {
+        totalLines,
+        truncatedContent: skipped <= 0
+            ? lines.join('\n')
+            : [...lines.slice(0, headTailLines), `\n... [${skipped} lines truncated] ...\n`, ...lines.slice(-headTailLines)].join('\n'),
+    };
+}
 //# sourceMappingURL=shell.js.map