erosolar-cli 2.1.238 → 2.1.240

package/dist/tools/bashTools.d.ts

@@ -1,8 +1,6 @@
 import type { ToolDefinition } from '../core/toolRuntime.js';
-export declare function createBashTools(workingDir: string): ToolDefinition[];
-interface SandboxEnvOptions {
+export declare function buildSandboxEnv(workingDir: string, options?: {
     preserveHome?: boolean;
-}
-export declare function buildSandboxEnv(workingDir: string, options?: SandboxEnvOptions): Promise<NodeJS.ProcessEnv>;
-export {};
+}): Promise<NodeJS.ProcessEnv>;
+export declare function createBashTools(workingDir: string): ToolDefinition[];
 //# sourceMappingURL=bashTools.d.ts.map

package/dist/tools/bashTools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bashTools.d.ts","sourceRoot":"","sources":["../../src/tools/bashTools.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAwM7D,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,EAAE,CAwMpE;AAED,UAAU,iBAAiB;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,wBAAsB,eAAe,CACnC,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CA6B5B"}
+{"version":3,"file":"bashTools.d.ts","sourceRoot":"","sources":["../../src/tools/bashTools.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AA8R7D,wBAAsB,eAAe,CACnC,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,GACnC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAqB5B;AAMD,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,EAAE,CAoOpE"}

package/dist/tools/bashTools.js

@@ -2,16 +2,105 @@ import { spawn } from 'node:child_process';
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { reportToolProgress } from '../core/toolRuntime.js';
-import { createBackgroundBashTools, startBackgroundShell } from './backgroundBashTools.js';
 import { validateBashCommand, SmartFixer } from '../core/errors/safetyValidator.js';
 import { toStructuredError } from '../core/errors/errorTypes.js';
 import { analyzeBashFlow } from '../core/bashCommandGuidance.js';
+import { buildError } from '../core/errors.js';
 import { verifiedSuccess, verifiedFailure, analyzeOutput, OutputPatterns, createCommandCheck, } from '../core/resultVerification.js';
 import { createErrorFixer } from '../core/aiErrorFixer.js';
-/**
- * Execute a bash command with streaming output via reportToolProgress.
- * This allows the UI to display live output as the command runs.
- */
+// ============================================================================
+// Background Shell Manager (consolidated from backgroundBashTools.ts)
+// ============================================================================
+class BackgroundShell {
+    id;
+    command;
+    workingDir;
+    process;
+    outputBuffer = [];
+    errorBuffer = [];
+    lastReadPosition = 0;
+    isRunning = false;
+    exitCode;
+    constructor(id, command, workingDir) {
+        this.id = id;
+        this.command = command;
+        this.workingDir = workingDir;
+    }
+    start() {
+        this.process = spawn('bash', ['-c', this.command], {
+            cwd: this.workingDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        this.isRunning = true;
+        this.process.stdout?.on('data', (data) => {
+            this.outputBuffer.push(data.toString());
+        });
+        this.process.stderr?.on('data', (data) => {
+            this.errorBuffer.push(data.toString());
+        });
+        this.process.on('exit', (code) => {
+            this.exitCode = code ?? 0;
+            this.isRunning = false;
+        });
+    }
+    getNewOutput(filter) {
+        const allOutput = this.outputBuffer.join('');
+        const newOutput = allOutput.substring(this.lastReadPosition);
+        this.lastReadPosition = allOutput.length;
+        const allError = this.errorBuffer.join('');
+        let stdout = newOutput;
+        if (filter) {
+            const lines = newOutput.split('\n');
+            stdout = lines.filter(line => filter.test(line)).join('\n');
+        }
+        return {
+            stdout,
+            stderr: allError,
+            status: this.isRunning ? 'running' : `exited with code ${this.exitCode}`,
+        };
+    }
+    kill() {
+        if (this.process) {
+            this.process.kill('SIGTERM');
+            setTimeout(() => {
+                if (this.process && !this.process.killed) {
+                    this.process.kill('SIGKILL');
+                }
+            }, 5000);
+        }
+    }
+}
+class BackgroundShellManager {
+    shells = new Map();
+    nextId = 1;
+    createShell(command, workingDir) {
+        const shellId = `shell_${this.nextId++}`;
+        const shell = new BackgroundShell(shellId, command, workingDir);
+        this.shells.set(shellId, shell);
+        shell.start();
+        return shellId;
+    }
+    getShell(shellId) {
+        return this.shells.get(shellId);
+    }
+    killShell(shellId) {
+        const shell = this.shells.get(shellId);
+        if (shell) {
+            shell.kill();
+            this.shells.delete(shellId);
+            return true;
+        }
+        return false;
+    }
+    listShells() {
+        return Array.from(this.shells.keys());
+    }
+}
+// Global shell manager instance
+const shellManager = new BackgroundShellManager();
+// ============================================================================
+// Streaming Execution
+// ============================================================================
 async function execWithStreaming(command, options) {
     return new Promise((resolve, reject) => {
         const stdout = [];
@@ -30,8 +119,7 @@ async function execWithStreaming(command, options) {
         }, options.timeout);
         const processLine = (line, isStderr) => {
             lineCount++;
-            // Report progress with the latest line
-            const trimmedLine = line.slice(0, 80); // Truncate long lines for display
+            const trimmedLine = line.slice(0, 80);
             reportToolProgress({
                 current: lineCount,
                 message: isStderr ? `stderr: ${trimmedLine}` : trimmedLine,
@@ -42,9 +130,8 @@ async function execWithStreaming(command, options) {
             const text = data.toString();
             stdout.push(text);
             stdoutBuffer += text;
-            // Process complete lines
             const lines = stdoutBuffer.split('\n');
-            stdoutBuffer = lines.pop() || ''; // Keep incomplete line in buffer
+            stdoutBuffer = lines.pop() || '';
             for (const line of lines) {
                 if (line.trim())
                     processLine(line, false);
@@ -55,7 +142,6 @@ async function execWithStreaming(command, options) {
             const text = data.toString();
             stderr.push(text);
             stderrBuffer += text;
-            // Process complete lines
             const lines = stderrBuffer.split('\n');
             stderrBuffer = lines.pop() || '';
             for (const line of lines) {
@@ -65,7 +151,6 @@ async function execWithStreaming(command, options) {
         });
         child.on('close', (code) => {
             clearTimeout(timeoutId);
-            // Process any remaining buffered content
             if (stdoutBuffer.trim())
                 processLine(stdoutBuffer, false);
             if (stderrBuffer.trim())
@@ -74,11 +159,7 @@ async function execWithStreaming(command, options) {
                 reject({ killed: true, stdout: stdout.join(''), stderr: stderr.join(''), code });
             }
             else {
-                resolve({
-                    stdout: stdout.join(''),
-                    stderr: stderr.join(''),
-                    exitCode: code ?? 0,
-                });
+                resolve({ stdout: stdout.join(''), stderr: stderr.join(''), exitCode: code ?? 0 });
             }
         });
         child.on('error', (error) => {
@@ -87,11 +168,13 @@ async function execWithStreaming(command, options) {
         });
     });
 }
+// ============================================================================
+// Utility Functions
+// ============================================================================
+// Keep the shell responsive while long commands run
 function findGuiLauncher(_command) {
-    // Kinetic capabilities enabled - GUI blocking disabled
     return null;
 }
-// Shared error fixer instance (lazy initialized per working dir)
 const errorFixerCache = new Map();
 function getErrorFixer(workingDir) {
     let fixer = errorFixerCache.get(workingDir);
@@ -101,18 +184,8 @@ function getErrorFixer(workingDir) {
     }
     return fixer;
 }
-const sandboxCache = new Map();
 /**
- * Smart timeout detection for bash commands.
- * Returns appropriate timeout based on command type.
- * - python/torch training & fine-tuning: 10 minutes
- * - npm install/ci: 5 minutes
- * - npm build/test: 5 minutes
- * - npx create-*: 5 minutes
- * - pytest/python -m pytest: 5 minutes
- * - docker build/pull: 10 minutes
- * - git clone: 3 minutes
- * - Default: 30 seconds
+ * Smart timeout detection based on command type
  */
 function getSmartTimeout(command) {
     const cmd = command.toLowerCase().trim();
@@ -120,96 +193,111 @@ function getSmartTimeout(command) {
     if (/\b(python|python3)\b/.test(cmd) && /\b(train|fine[-\s]?tune|finetune)\b/.test(cmd)) {
         return 600000;
     }
-    // Torch/accelerate launchers (10 minutes)
-    if (/\b(torchrun|accelerate\s+launch)\b/.test(cmd)) {
+    if (/\b(torchrun|accelerate\s+launch)\b/.test(cmd))
         return 600000;
-    }
     // Python/pytest test runners (5 minutes)
-    if (/\b(pytest|python\s+-m\s+pytest)\b/.test(cmd)) {
+    if (/\b(pytest|python\s+-m\s+pytest)\b/.test(cmd))
         return 300000;
-    }
-    // NPM/Yarn/PNPM package operations (5 minutes)
-    if (/\b(npm|yarn|pnpm)\s+(install|ci|i|add|update|upgrade)\b/.test(cmd)) {
+    // NPM/Yarn/PNPM operations (5 minutes)
+    if (/\b(npm|yarn|pnpm)\s+(install|ci|i|add|update|upgrade)\b/.test(cmd))
         return 300000;
-    }
-    // NPM/Yarn build and test operations (5 minutes)
-    if (/\b(npm|yarn|pnpm)\s+(run\s+)?(build|test|lint|start|dev)\b/.test(cmd)) {
+    if (/\b(npm|yarn|pnpm)\s+(run\s+)?(build|test|lint|start|dev)\b/.test(cmd))
         return 300000;
-    }
-    // NPX create commands (5 minutes)
-    if (/\bnpx\s+(create-|degit|giget)\b/.test(cmd)) {
+    if (/\bnpx\s+(create-|degit|giget)\b/.test(cmd))
         return 300000;
-    }
-    // Prisma operations (3 minutes)
-    if (/\b(prisma|npx prisma)\s+(generate|migrate|db push|db pull)\b/.test(cmd)) {
+    // Prisma (3 minutes)
+    if (/\b(prisma|npx prisma)\s+(generate|migrate|db push|db pull)\b/.test(cmd))
         return 180000;
-    }
-    // Docker operations (10 minutes)
-    if (/\bdocker\s+(build|pull|push|compose)\b/.test(cmd)) {
+    // Docker (10 minutes)
+    if (/\bdocker\s+(build|pull|push|compose)\b/.test(cmd))
         return 600000;
-    }
-    // Git clone (3 minutes)
-    if (/\bgit\s+clone\b/.test(cmd)) {
+    // Git clone / pip install (3 minutes)
+    if (/\bgit\s+clone\b/.test(cmd))
         return 180000;
-    }
-    // Pip install (3 minutes)
-    if (/\bpip\s+install\b/.test(cmd)) {
+    if (/\bpip\s+install\b/.test(cmd))
         return 180000;
+    return 30000; // Default
+}
+const sandboxCache = new Map();
+async function ensureSandboxPaths(workingDir) {
+    let pending = sandboxCache.get(workingDir);
+    if (!pending) {
+        pending = createSandboxPaths(workingDir);
+        sandboxCache.set(workingDir, pending);
     }
-    // Default timeout
-    return 30000;
+    return pending;
 }
+async function createSandboxPaths(workingDir) {
+    const root = join(workingDir, '.erosolar', 'shell-sandbox');
+    const home = join(root, 'home');
+    const cache = join(root, 'cache');
+    const config = join(root, 'config');
+    const data = join(root, 'data');
+    const tmp = join(root, 'tmp');
+    await Promise.all([home, cache, config, data, tmp].map((dir) => mkdir(dir, { recursive: true })));
+    return { root, home, cache, config, data, tmp };
+}
+export async function buildSandboxEnv(workingDir, options) {
+    const envPreference = process.env['EROSOLAR_PRESERVE_HOME'];
+    const preserveHome = envPreference === '1' ? true : envPreference === '0' ? false : Boolean(options?.preserveHome);
+    const paths = await ensureSandboxPaths(workingDir);
+    const env = {
+        ...process.env,
+        EROSOLAR_SANDBOX_ROOT: paths.root,
+        EROSOLAR_SANDBOX_HOME: paths.home,
+        EROSOLAR_SANDBOX_TMP: paths.tmp,
+    };
+    if (!preserveHome)
+        env['HOME'] = paths.home;
+    env['XDG_CACHE_HOME'] = paths.cache;
+    env['XDG_CONFIG_HOME'] = paths.config;
+    env['XDG_DATA_HOME'] = paths.data;
+    env['TMPDIR'] = paths.tmp;
+    env['TMP'] = paths.tmp;
+    env['TEMP'] = paths.tmp;
+    return env;
+}
+// ============================================================================
+// Main Tool Factory
+// ============================================================================
 export function createBashTools(workingDir) {
-    const backgroundTools = createBackgroundBashTools(workingDir);
     return [
+        // Main bash execution tool
         {
             name: 'execute_bash',
-            description: 'Execute a bash command in the working directory. Commands auto-timeout based on type: npm/docker/git commands get extended timeouts. Exit code 0 = success, non-zero = failure. Use run_in_background: true for long-running servers/watchers. IMPORTANT: Always check command output for errors even if exit code is 0.',
+            description: 'Execute a bash command. Commands auto-timeout based on type. Use run_in_background: true for servers/watchers.',
             parameters: {
                 type: 'object',
                 properties: {
-                    command: {
-                        type: 'string',
-                        description: 'The bash command to execute (e.g., "npm test", "git status", "ls -la"). Will be validated for safety before execution.',
-                    },
-                    timeout: {
-                        type: 'number',
-                        description: 'Timeout in milliseconds. Default is smart: 30s for most commands, 5min for npm/docker, 3min for git clone. Not used when run_in_background is true.',
-                    },
-                    run_in_background: {
-                        type: 'boolean',
-                        description: 'Set to true to run this command in the background (for servers, watchers, long-running processes). Returns a shell ID that can be used with BashOutput to monitor output.',
-                    },
+                    command: { type: 'string', description: 'The bash command to execute' },
+                    timeout: { type: 'number', description: 'Timeout in milliseconds (smart defaults apply)' },
+                    run_in_background: { type: 'boolean', description: 'Run in background for long-running processes' },
                 },
                 required: ['command'],
             },
             handler: async (args) => {
                 const command = args['command'];
                 const runInBackground = args['run_in_background'] === true;
-                // Smart timeout: auto-extend for known long-running commands
                 const userTimeout = args['timeout'];
                 const timeout = userTimeout ?? getSmartTimeout(command);
-                // Lightweight flow guidance (publish/git) without blocking execution
+                // Flow guidance
                 const flowWarnings = analyzeBashFlow(command);
                 for (const warning of flowWarnings) {
                     const suffix = warning.suggestion ? ` — ${warning.suggestion}` : '';
                     console.warn(`[Bash Flow] ${warning.message}${suffix}`);
                 }
-                // Enhanced safety validation with structured errors
+                // Safety validation
                 const validation = validateBashCommand(command);
                 if (!validation.valid) {
                     const structuredError = validation.error ? toStructuredError(validation.error) : null;
                     if (structuredError) {
-                        // Return formatted error with suggestions
                         let errorMsg = structuredError.toDisplayString();
-                        // Add auto-fix suggestion if available
                         if (validation.autoFix?.available) {
                             const { fixed, changes } = SmartFixer.fixDangerousCommand(command);
                             if (changes.length > 0) {
                                 errorMsg += '\n\nAuto-fix available:';
-                                for (const change of changes) {
+                                for (const change of changes)
                                     errorMsg += `\n  - ${change}`;
-                                }
                                 errorMsg += `\n\nFixed command: ${fixed}`;
                             }
                         }
@@ -217,67 +305,50 @@ export function createBashTools(workingDir) {
                     }
                     return 'Error: Command validation failed';
                 }
-                // Log warnings if any
                 if (validation.warnings.length > 0) {
                     for (const warning of validation.warnings) {
                         console.warn(`[Bash Safety] ${warning}`);
                     }
                 }
-                // Block GUI/permission pop-up commands by default
+                // GUI blocking check (disabled for red team ops)
                 const guiBlocked = findGuiLauncher(command);
                 if (guiBlocked) {
-                    return `Blocked GUI/launcher command "${guiBlocked}". erosolar-cli runs headless and will not launch GUI apps or keychain dialogs.`;
+                    return `Blocked: ${guiBlocked}`;
                 }
-                // Handle background execution
+                // Background execution
                 if (runInBackground) {
-                    const shellId = startBackgroundShell(command, workingDir);
-                    return `Background shell started: ${shellId}\n\nUse BashOutput with bash_id="${shellId}" to monitor output.\nUse KillShell with shell_id="${shellId}" to terminate.`;
+                    const shellId = shellManager.createShell(command, workingDir);
+                    return `Background shell started: ${shellId}\n\nUse BashOutput with bash_id="${shellId}" to monitor.\nUse KillShell with shell_id="${shellId}" to terminate.`;
                 }
-                // Handle foreground execution with streaming output
+                // Foreground execution
                 const startTime = Date.now();
                 try {
                     const env = await buildSandboxEnv(workingDir);
-                    const { stdout, stderr, exitCode } = await execWithStreaming(command, {
-                        cwd: workingDir,
-                        timeout,
-                        env,
-                    });
+                    const { stdout, stderr, exitCode } = await execWithStreaming(command, { cwd: workingDir, timeout, env });
                     const durationMs = Date.now() - startTime;
                     const combinedOutput = [stdout, stderr].filter(Boolean).join('\n');
-                    // Select appropriate patterns based on command type
                     const commandLower = command.toLowerCase().trim();
                     let patterns = OutputPatterns.command;
-                    if (commandLower.startsWith('git ') || commandLower === 'git') {
+                    if (commandLower.startsWith('git ') || commandLower === 'git')
                         patterns = OutputPatterns.git;
-                    }
-                    else if (commandLower.startsWith('npm ') || commandLower.startsWith('npx ')) {
+                    else if (commandLower.startsWith('npm ') || commandLower.startsWith('npx '))
                         patterns = OutputPatterns.npm;
-                    }
-                    // Analyze the output to determine actual success
                     const analysis = analyzeOutput(combinedOutput, patterns, exitCode);
                     const commandCheck = createCommandCheck('Command execution', exitCode, combinedOutput);
-                    // Non-zero exit code = failure
                     if (exitCode !== 0) {
-                        // AI Error Analysis - automatically analyze failures
                         const errorFixer = getErrorFixer(workingDir);
                         const aiErrors = errorFixer.analyzeOutput(combinedOutput, command);
                         const aiGuidance = aiErrors.length > 0 ? errorFixer.formatForAI(aiErrors) : '';
-                        const suggestions = ['Review the error message', 'Fix the issue and retry the command'];
+                        const suggestions = ['Review the error message', 'Fix the issue and retry'];
                         const firstError = aiErrors[0];
-                        if (firstError && firstError.suggestedFixes.length > 0) {
-                            const bestFix = firstError.suggestedFixes[0];
-                            if (bestFix) {
-                                suggestions.unshift(`AI Suggestion: ${bestFix.description}`);
-                            }
+                        if (firstError?.suggestedFixes[0]) {
+                            suggestions.unshift(`AI Suggestion: ${firstError.suggestedFixes[0].description}`);
                         }
                         return verifiedFailure(`Command failed with exit code ${exitCode}`, `Command: ${command}\n\nOutput:\n${combinedOutput || '(none)'}${aiGuidance}`, suggestions, [commandCheck], durationMs);
                     }
-                    // Check for explicit failure patterns in output despite exit code 0
-                    // Some commands exit 0 but print errors (e.g., "error:" in output)
                     if (analysis.isFailure) {
-                        return verifiedFailure(`Command completed with exit code 0 but output indicates failure`, `Command: ${command}\n\nOutput:\n${combinedOutput || '(no output)'}`, ['Review the error message in the output', 'Fix the underlying issue and retry'], [commandCheck, { check: 'Output analysis', passed: false, details: `Failure pattern matched: ${analysis.matchedPattern}` }], durationMs);
+                        return verifiedFailure(`Command completed with exit code 0 but output indicates failure`, `Command: ${command}\n\nOutput:\n${combinedOutput || '(no output)'}`, ['Review the error message in the output', 'Fix the underlying issue and retry'], [commandCheck, { check: 'Output analysis', passed: false, details: `Failure pattern: ${analysis.matchedPattern}` }], durationMs);
                     }
-                    // Exit code 0 + no failure patterns = success
                     return verifiedSuccess(combinedOutput.trim() ? `Command executed successfully` : `Command executed successfully (no output)`, `Command: ${command}${combinedOutput.trim() ? `\n\nOutput:\n${combinedOutput}` : ''}`, [commandCheck, ...(analysis.isSuccess ? [{ check: 'Output analysis', passed: true, details: `Success pattern matched` }] : [])], durationMs);
                 }
                 catch (error) {
@@ -286,70 +357,97 @@ export function createBashTools(workingDir) {
                     const exitCode = execError.code ?? 1;
                     const combinedError = [execError.stdout, execError.stderr, execError.message].filter(Boolean).join('\n');
                     if (execError.killed) {
-                        return verifiedFailure(`Command timed out after ${timeout}ms`, `Command: ${command}\n\nThe command was killed after exceeding the timeout.\nPartial output:\n${combinedError || '(none)'}`, ['Increase timeout if command legitimately needs more time', 'Check if command is hanging on input'], [{ check: 'Timeout', passed: false, details: `Exceeded ${timeout}ms` }], durationMs);
+                        return verifiedFailure(`Command timed out after ${timeout}ms`, `Command: ${command}\n\nPartial output:\n${combinedError || '(none)'}`, ['Increase timeout if command legitimately needs more time', 'Check if command is hanging'], [{ check: 'Timeout', passed: false, details: `Exceeded ${timeout}ms` }], durationMs);
                     }
-                    // AI Error Analysis - automatically analyze failures
                     const errorFixer = getErrorFixer(workingDir);
                     const aiErrors = errorFixer.analyzeOutput(combinedError, command);
                     const aiGuidance = aiErrors.length > 0 ? errorFixer.formatForAI(aiErrors) : '';
-                    // Build suggestions with AI help
-                    const suggestions = ['Review the error message', 'Fix the issue and retry the command'];
+                    const suggestions = ['Review the error message', 'Fix the issue and retry'];
                     const firstError = aiErrors[0];
-                    if (firstError && firstError.suggestedFixes.length > 0) {
-                        const bestFix = firstError.suggestedFixes[0];
-                        if (bestFix) {
-                            suggestions.unshift(`AI Suggestion: ${bestFix.description}`);
-                        }
+                    if (firstError?.suggestedFixes[0]) {
+                        suggestions.unshift(`AI Suggestion: ${firstError.suggestedFixes[0].description}`);
                     }
                     return verifiedFailure(`Command failed with exit code ${exitCode}`, `Command: ${command}\n\nError output:\n${combinedError || '(none)'}${aiGuidance}`, suggestions, [createCommandCheck('Command execution', exitCode, combinedError)], durationMs);
                 }
             },
         },
-        ...backgroundTools,
+        // Background shell output retrieval
+        {
+            name: 'BashOutput',
+            description: 'Retrieve output from a running or completed background bash shell.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    bash_id: { type: 'string', description: 'The ID of the background shell' },
+                    filter: { type: 'string', description: 'Optional regex to filter output lines' },
+                },
+                required: ['bash_id'],
+                additionalProperties: false,
+            },
+            handler: async (args) => {
+                const bashId = args['bash_id'];
+                const filterStr = args['filter'];
+                if (typeof bashId !== 'string' || !bashId.trim()) {
+                    return 'Error: bash_id must be a non-empty string.';
+                }
+                try {
+                    const shell = shellManager.getShell(bashId);
+                    if (!shell) {
+                        const available = shellManager.listShells();
+                        return `Error: Shell "${bashId}" not found.\n\nAvailable: ${available.length > 0 ? available.join(', ') : 'none'}`;
+                    }
+                    const filter = filterStr && typeof filterStr === 'string' ? new RegExp(filterStr) : undefined;
+                    const { stdout, stderr, status } = shell.getNewOutput(filter);
+                    const parts = [`Shell: ${bashId}`, `Status: ${status}`];
+                    if (stdout) {
+                        parts.push('\n=== New Output ===');
+                        parts.push(stdout);
+                    }
+                    if (stderr) {
+                        parts.push('\n=== Errors ===');
+                        parts.push(stderr);
+                    }
+                    if (!stdout && !stderr)
+                        parts.push('\n(No new output)');
+                    return parts.join('\n');
+                }
+                catch (error) {
+                    return buildError('retrieving shell output', error, { bash_id: bashId });
+                }
+            },
+        },
+        // Kill background shell
+        {
+            name: 'KillShell',
+            description: 'Kill a running background bash shell by its ID.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    shell_id: { type: 'string', description: 'The ID of the background shell to kill' },
+                },
+                required: ['shell_id'],
+                additionalProperties: false,
+            },
+            handler: async (args) => {
+                const shellId = args['shell_id'];
+                if (typeof shellId !== 'string' || !shellId.trim()) {
+                    return 'Error: shell_id must be a non-empty string.';
+                }
+                try {
+                    const success = shellManager.killShell(shellId);
+                    if (success) {
+                        return `Shell "${shellId}" has been terminated.`;
+                    }
+                    else {
+                        const available = shellManager.listShells();
+                        return `Error: Shell "${shellId}" not found.\n\nAvailable: ${available.length > 0 ? available.join(', ') : 'none'}`;
+                    }
+                }
+                catch (error) {
+                    return buildError('killing shell', error, { shell_id: shellId });
+                }
+            },
+        },
     ];
 }
-export async function buildSandboxEnv(workingDir, options) {
-    const envPreference = process.env['EROSOLAR_PRESERVE_HOME'];
-    const preserveHome = envPreference === '1'
-        ? true
-        : envPreference === '0'
-            ? false
-            : Boolean(options?.preserveHome);
-    const paths = await ensureSandboxPaths(workingDir);
-    const env = {
-        ...process.env,
-        EROSOLAR_SANDBOX_ROOT: paths.root,
-        EROSOLAR_SANDBOX_HOME: paths.home,
-        EROSOLAR_SANDBOX_TMP: paths.tmp,
-    };
-    if (!preserveHome) {
-        env['HOME'] = paths.home;
-    }
-    env['XDG_CACHE_HOME'] = paths.cache;
-    env['XDG_CONFIG_HOME'] = paths.config;
-    env['XDG_DATA_HOME'] = paths.data;
-    env['TMPDIR'] = paths.tmp;
-    env['TMP'] = paths.tmp;
-    env['TEMP'] = paths.tmp;
-    return env;
-}
-async function ensureSandboxPaths(workingDir) {
-    const key = workingDir;
-    let pending = sandboxCache.get(key);
-    if (!pending) {
-        pending = createSandboxPaths(workingDir);
-        sandboxCache.set(key, pending);
-    }
-    return pending;
-}
-async function createSandboxPaths(workingDir) {
-    const root = join(workingDir, '.erosolar', 'shell-sandbox');
-    const home = join(root, 'home');
-    const cache = join(root, 'cache');
-    const config = join(root, 'config');
-    const data = join(root, 'data');
-    const tmp = join(root, 'tmp');
-    await Promise.all([home, cache, config, data, tmp].map((dir) => mkdir(dir, { recursive: true })));
-    return { root, home, cache, config, data, tmp };
-}
 //# sourceMappingURL=bashTools.js.map