erosolar-cli 1.7.55 → 1.7.57

package/dist/bin/tools/backgroundBashTools.js

@@ -1,211 +0,0 @@
-import { spawn } from 'node:child_process';
-import { buildError } from '../core/errors.js';
-/**
- * Background Bash Shell Manager
- *
- * Manages long-running background bash shells with output buffering.
- */
-class BackgroundShellManager {
-    constructor() {
-        this.shells = new Map();
-        this.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());
-    }
-}
-class BackgroundShell {
-    constructor(id, command, _workingDir) {
-        this.id = id;
-        this.command = command;
-        this._workingDir = _workingDir;
-        this.outputBuffer = [];
-        this.errorBuffer = [];
-        this.lastReadPosition = 0;
-        this.isRunning = false;
-    }
-    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');
-            const filtered = lines.filter(line => filter.test(line));
-            stdout = filtered.join('\n');
-        }
-        const status = this.isRunning
-            ? 'running'
-            : `exited with code ${this.exitCode}`;
-        return {
-            stdout,
-            stderr: allError,
-            status,
-        };
-    }
-    kill() {
-        if (this.process) {
-            this.process.kill('SIGTERM');
-            setTimeout(() => {
-                if (this.process && !this.process.killed) {
-                    this.process.kill('SIGKILL');
-                }
-            }, 5000);
-        }
-    }
-    getStatus() {
-        return this.isRunning ? 'running' : `exited with code ${this.exitCode}`;
-    }
-}
-// Global manager instance
-const shellManager = new BackgroundShellManager();
-/**
- * Creates background bash management tools
- *
- * Tools:
- * - Bash (with run_in_background): Start background processes
- * - BashOutput: Retrieve output from background shells
- * - KillShell: Terminate background shells
- *
- * @param _workingDir - The working directory for commands (reserved for future use)
- * @returns Array of tool definitions
- */
-export function createBackgroundBashTools(_workingDir) {
-    return [
-        {
-            name: 'BashOutput',
-            description: 'Retrieves output from a running or completed background bash shell. Always returns only new output since the last check.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    bash_id: {
-                        type: 'string',
-                        description: 'The ID of the background shell to retrieve output from',
-                    },
-                    filter: {
-                        type: 'string',
-                        description: 'Optional regular expression to filter the output lines. Only lines matching this regex will be included.',
-                    },
-                },
-                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 shells: ${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 = [];
-                    parts.push(`Shell: ${bashId}`);
-                    parts.push(`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 });
-                }
-            },
-        },
-        {
-            name: 'KillShell',
-            description: 'Kills a running background bash shell by its ID. Returns success or failure status.',
-            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 shells: ${available.length > 0 ? available.join(', ') : 'none'}`;
-                    }
-                }
-                catch (error) {
-                    return buildError('killing shell', error, { shell_id: shellId });
-                }
-            },
-        },
-    ];
-}
-/**
- * Start a background bash command
- *
- * This should be integrated into the main Bash tool with a run_in_background parameter.
- * For now, it's exported as a helper function.
- */
-export function startBackgroundShell(command, workingDir) {
-    return shellManager.createShell(command, workingDir);
-}

package/dist/bin/tools/bashTools.js

@@ -1,159 +0,0 @@
-import { exec } from 'node:child_process';
-import { mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { promisify } from 'node:util';
-import { createBackgroundBashTools, startBackgroundShell } from './backgroundBashTools.js';
-import { validateBashCommand, SmartFixer } from '../core/errors/safetyValidator.js';
-import { toStructuredError } from '../core/errors/errorTypes.js';
-const execAsync = promisify(exec);
-const sandboxCache = new Map();
-export function createBashTools(workingDir) {
-    const backgroundTools = createBackgroundBashTools(workingDir);
-    return [
-        {
-            name: 'execute_bash',
-            description: 'Execute a bash command in the working directory. Use run_in_background: true to run commands in the background and monitor with BashOutput.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    command: {
-                        type: 'string',
-                        description: 'The bash command to execute',
-                    },
-                    timeout: {
-                        type: 'number',
-                        description: 'Timeout in milliseconds (default: 30000). Not used when run_in_background is true.',
-                    },
-                    run_in_background: {
-                        type: 'boolean',
-                        description: 'Set to true to run this command in the background. Returns a shell ID that can be used with BashOutput to monitor output.',
-                    },
-                },
-                required: ['command'],
-            },
-            handler: async (args) => {
-                const command = args['command'];
-                const timeout = args['timeout'] || 30000;
-                const runInBackground = args['run_in_background'] === true;
-                // Enhanced safety validation with structured errors
-                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) {
-                                    errorMsg += `\n  - ${change}`;
-                                }
-                                errorMsg += `\n\nFixed command: ${fixed}`;
-                            }
-                        }
-                        return errorMsg;
-                    }
-                    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}`);
-                    }
-                }
-                // Handle 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.`;
-                }
-                // Handle foreground execution
-                try {
-                    const env = await buildSandboxEnv(workingDir);
-                    const { stdout, stderr } = await execAsync(command, {
-                        cwd: workingDir,
-                        timeout,
-                        maxBuffer: 1024 * 1024 * 10, // 10MB
-                        env,
-                    });
-                    let result = '';
-                    if (stdout)
-                        result += `stdout:\n${stdout}\n`;
-                    if (stderr)
-                        result += `stderr:\n${stderr}\n`;
-                    return result || 'Command executed successfully (no output)';
-                }
-                catch (error) {
-                    if (error.killed) {
-                        return `Error: Command timed out after ${timeout}ms`;
-                    }
-                    return `Error executing command: ${error.message}\nstderr: ${error.stderr || 'none'}`;
-                }
-            },
-        },
-        {
-            name: 'execute_bash_stream',
-            description: 'Execute a bash command and stream output (for long-running commands)',
-            parameters: {
-                type: 'object',
-                properties: {
-                    command: {
-                        type: 'string',
-                        description: 'The bash command to execute',
-                    },
-                },
-                required: ['command'],
-            },
-            handler: async (_args) => {
-                await buildSandboxEnv(workingDir);
-                return 'Stream execution not yet implemented - use execute_bash instead';
-            },
-        },
-        ...backgroundTools,
-    ];
-}
-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 };
-}