orquesta-cli 0.1.12 → 0.1.14

package/src/tools/llm/simple/background-powershell-tool.ts

@@ -1,421 +0,0 @@
-/**
- * Background PowerShell Tool (Native Windows Only)
- *
- * Tool for running and managing PowerShell processes in the background
- * Useful for long-running commands like npm run dev, npm start, etc.
- */
-
-import { spawn, ChildProcess } from 'child_process';
-import { ToolDefinition } from '../../../types/index.js';
-import { LLMSimpleTool, ToolResult, ToolCategory } from '../../types.js';
-import { logger } from '../../../utils/logger.js';
-import { isNativeWindows, findNativePowerShellPath } from '../../../utils/platform-utils.js';
-import { filterSafeEnv } from '../../../utils/env-filter.js';
-import { configManager } from '../../../core/config/config-manager.js';
-
-/**
- * Background process info
- */
-interface BackgroundProcess {
-  id: string;
-  command: string;
-  process: ChildProcess;
-  startedAt: Date;
-  cwd: string;
-  output: string[];
-  maxOutputLines: number;
-}
-
-/**
- * Background PowerShell Process Manager
- */
-class BackgroundPowerShellProcessManager {
-  private processes: Map<string, BackgroundProcess> = new Map();
-  private nextId = 1;
-
-  /**
-   * Start a background process
-   */
-  start(command: string, cwd?: string, explicitEnv?: Record<string, string>): { id: string; pid: number } {
-    const id = `ps-bg-${this.nextId++}`;
-    const workingDir = cwd || process.cwd();
-
-    const psPath = findNativePowerShellPath();
-
-    // Get user-configured safe env vars
-    const userSafeVars = configManager.getSafeEnvVars();
-
-    const child = spawn(psPath, ['-NoProfile', '-Command', command], {
-      cwd: workingDir,
-      env: filterSafeEnv(process.env, userSafeVars, explicitEnv || {}), // Merge: filtered process.env + user config + explicit vars
-      detached: false,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    const bgProcess: BackgroundProcess = {
-      id,
-      command,
-      process: child,
-      startedAt: new Date(),
-      cwd: workingDir,
-      output: [],
-      maxOutputLines: 100,
-    };
-
-    // Capture output
-    child.stdout?.on('data', (data) => {
-      const lines = data.toString().split('\n').filter((l: string) => l.trim());
-      bgProcess.output.push(...lines);
-      // Keep only last N lines
-      if (bgProcess.output.length > bgProcess.maxOutputLines) {
-        bgProcess.output = bgProcess.output.slice(-bgProcess.maxOutputLines);
-      }
-    });
-
-    child.stderr?.on('data', (data) => {
-      const lines = data.toString().split('\n').filter((l: string) => l.trim());
-      bgProcess.output.push(...lines.map((l: string) => `[stderr] ${l}`));
-      if (bgProcess.output.length > bgProcess.maxOutputLines) {
-        bgProcess.output = bgProcess.output.slice(-bgProcess.maxOutputLines);
-      }
-    });
-
-    child.on('close', (code) => {
-      bgProcess.output.push(`[Process exited with code ${code}]`);
-    });
-
-    child.on('error', (error) => {
-      bgProcess.output.push(`[Error: ${error.message}]`);
-    });
-
-    this.processes.set(id, bgProcess);
-
-    return { id, pid: child.pid || 0 };
-  }
-
-  /**
-   * Kill a background process
-   */
-  kill(id: string): boolean {
-    const bgProcess = this.processes.get(id);
-    if (!bgProcess) {
-      return false;
-    }
-
-    try {
-      bgProcess.process.kill('SIGTERM');
-      // Give it a moment, then force kill if needed
-      setTimeout(() => {
-        if (!bgProcess.process.killed) {
-          bgProcess.process.kill('SIGKILL');
-        }
-      }, 2000);
-      this.processes.delete(id);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Get process status
-   */
-  getStatus(id: string): { running: boolean; output: string[] } | null {
-    const bgProcess = this.processes.get(id);
-    if (!bgProcess) {
-      return null;
-    }
-
-    return {
-      running: !bgProcess.process.killed && bgProcess.process.exitCode === null,
-      output: bgProcess.output.slice(-20), // Last 20 lines
-    };
-  }
-
-  /**
-   * List all processes
-   */
-  list(): Array<{
-    id: string;
-    command: string;
-    pid: number;
-    running: boolean;
-    startedAt: Date;
-    cwd: string;
-  }> {
-    return Array.from(this.processes.values()).map(p => ({
-      id: p.id,
-      command: p.command,
-      pid: p.process.pid || 0,
-      running: !p.process.killed && p.process.exitCode === null,
-      startedAt: p.startedAt,
-      cwd: p.cwd,
-    }));
-  }
-
-  /**
-   * Kill all processes
-   */
-  killAll(): number {
-    let killed = 0;
-    for (const [id] of this.processes) {
-      if (this.kill(id)) {
-        killed++;
-      }
-    }
-    return killed;
-  }
-}
-
-// Global instance
-export const backgroundPowerShellProcessManager = new BackgroundPowerShellProcessManager();
-
-/**
- * powershell_background Tool Definition
- */
-const POWERSHELL_BACKGROUND_DEFINITION: ToolDefinition = {
-  type: 'function',
-  function: {
-    name: 'powershell_background',
-    description: `Start a PowerShell command in the background on Windows. Use this for long-running processes like:
-- npm run dev (development server)
-- npm start (application server)
-- python -m http.server (simple HTTP server)
-- docker-compose up
-
-The command will continue running after this tool returns.
-Use powershell_background_status to check output, or powershell_background_kill to stop it.`,
-    parameters: {
-      type: 'object',
-      properties: {
-        reason: {
-          type: 'string',
-          description: 'Explanation of why you are running this in background',
-        },
-        command: {
-          type: 'string',
-          description: 'The PowerShell command to run in background',
-        },
-        cwd: {
-          type: 'string',
-          description: 'Working directory (optional)',
-        },
-      },
-      required: ['reason', 'command'],
-    },
-  },
-};
-
-async function executePowerShellBackground(args: Record<string, unknown>): Promise<ToolResult> {
-  const command = args['command'] as string;
-  const cwd = args['cwd'] as string | undefined;
-
-  logger.enter('powershellBackground.execute', { command, cwd });
-
-  // Check platform - should only run on Native Windows
-  if (!isNativeWindows()) {
-    return {
-      success: false,
-      error: 'powershell_background tool is only available on Native Windows. Use bash_background instead.',
-    };
-  }
-
-  try {
-    const { id, pid } = backgroundPowerShellProcessManager.start(command, cwd);
-
-    // Wait a moment to check if it started successfully
-    await new Promise(r => setTimeout(r, 1000));
-
-    const status = backgroundPowerShellProcessManager.getStatus(id);
-    const running = status?.running ?? false;
-
-    if (!running) {
-      const output = status?.output.join('\n') || '(no output)';
-      return {
-        success: false,
-        error: `Process failed to start or exited immediately.\nOutput:\n${output}`,
-      };
-    }
-
-    logger.exit('powershellBackground.execute', { id, pid });
-
-    return {
-      success: true,
-      result: `Background process started\nID: ${id}\nPID: ${pid}\nCommand: ${command}\n\nUse powershell_background_status with id="${id}" to check output.\nUse powershell_background_kill with id="${id}" to stop it.`,
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      error: `Failed to start background process: ${errorMessage}`,
-    };
-  }
-}
-
-export const powershellBackgroundTool: LLMSimpleTool = {
-  definition: POWERSHELL_BACKGROUND_DEFINITION,
-  execute: executePowerShellBackground,
-  categories: ['llm-simple'] as ToolCategory[],
-  description: 'Run PowerShell command in background',
-};
-
-/**
- * powershell_background_status Tool Definition
- */
-const POWERSHELL_BACKGROUND_STATUS_DEFINITION: ToolDefinition = {
-  type: 'function',
-  function: {
-    name: 'powershell_background_status',
-    description: `Check the status and recent output of a background PowerShell process.
-Use this to see if a server started successfully or to check for errors.`,
-    parameters: {
-      type: 'object',
-      properties: {
-        reason: {
-          type: 'string',
-          description: 'Explanation of why you are checking status',
-        },
-        id: {
-          type: 'string',
-          description: 'The process ID (e.g., "ps-bg-1") returned by powershell_background',
-        },
-      },
-      required: ['reason', 'id'],
-    },
-  },
-};
-
-async function executePowerShellBackgroundStatus(args: Record<string, unknown>): Promise<ToolResult> {
-  const id = args['id'] as string;
-
-  // Check platform
-  if (!isNativeWindows()) {
-    return {
-      success: false,
-      error: 'powershell_background_status tool is only available on Native Windows.',
-    };
-  }
-
-  const status = backgroundPowerShellProcessManager.getStatus(id);
-
-  if (!status) {
-    // Check if it's a list request
-    if (!id || id === 'list') {
-      const processes = backgroundPowerShellProcessManager.list();
-      if (processes.length === 0) {
-        return {
-          success: true,
-          result: 'No background PowerShell processes running.',
-        };
-      }
-
-      const list = processes.map(p => {
-        const status = p.running ? 'running' : 'stopped';
-        return `- ${p.id}: ${p.command} (PID: ${p.pid}, ${status})`;
-      }).join('\n');
-
-      return {
-        success: true,
-        result: `Background PowerShell processes:\n${list}`,
-      };
-    }
-
-    return {
-      success: false,
-      error: `No background process found with ID: ${id}`,
-    };
-  }
-
-  const statusStr = status.running ? 'Running' : 'Stopped';
-  const output = status.output.length > 0
-    ? status.output.join('\n')
-    : '(no output yet)';
-
-  return {
-    success: true,
-    result: `Process ${id}:\nStatus: ${statusStr}\n\nRecent output:\n${output}`,
-  };
-}
-
-export const powershellBackgroundStatusTool: LLMSimpleTool = {
-  definition: POWERSHELL_BACKGROUND_STATUS_DEFINITION,
-  execute: executePowerShellBackgroundStatus,
-  categories: ['llm-simple'] as ToolCategory[],
-  description: 'Check background PowerShell process status',
-};
-
-/**
- * powershell_background_kill Tool Definition
- */
-const POWERSHELL_BACKGROUND_KILL_DEFINITION: ToolDefinition = {
-  type: 'function',
-  function: {
-    name: 'powershell_background_kill',
-    description: `Stop a background PowerShell process.
-Use this to stop development servers, watchers, or other long-running processes.`,
-    parameters: {
-      type: 'object',
-      properties: {
-        reason: {
-          type: 'string',
-          description: 'Explanation of why you are killing this process',
-        },
-        id: {
-          type: 'string',
-          description: 'The process ID (e.g., "ps-bg-1") to kill, or "all" to kill all background processes',
-        },
-      },
-      required: ['reason', 'id'],
-    },
-  },
-};
-
-async function executePowerShellBackgroundKill(args: Record<string, unknown>): Promise<ToolResult> {
-  const id = args['id'] as string;
-
-  // Check platform
-  if (!isNativeWindows()) {
-    return {
-      success: false,
-      error: 'powershell_background_kill tool is only available on Native Windows.',
-    };
-  }
-
-  if (id === 'all') {
-    const killed = backgroundPowerShellProcessManager.killAll();
-    return {
-      success: true,
-      result: `Killed ${killed} background PowerShell process(es).`,
-    };
-  }
-
-  const success = backgroundPowerShellProcessManager.kill(id);
-
-  if (!success) {
-    return {
-      success: false,
-      error: `No background process found with ID: ${id}`,
-    };
-  }
-
-  return {
-    success: true,
-    result: `Background process ${id} has been killed.`,
-  };
-}
-
-export const powershellBackgroundKillTool: LLMSimpleTool = {
-  definition: POWERSHELL_BACKGROUND_KILL_DEFINITION,
-  execute: executePowerShellBackgroundKill,
-  categories: ['llm-simple'] as ToolCategory[],
-  description: 'Kill background PowerShell process',
-};
-
-/**
- * All background PowerShell tools
- */
-export const BACKGROUND_POWERSHELL_TOOLS: LLMSimpleTool[] = [
-  powershellBackgroundTool,
-  powershellBackgroundStatusTool,
-  powershellBackgroundKillTool,
-];

package/src/tools/llm/simple/bash-tool.ts

@@ -1,238 +0,0 @@
-/**
- * Bash Tool (WSL/Linux Only)
- *
- * Tool that allows LLM to execute bash shell commands
- * Only registered in WSL and Native Linux environments
- * Native Windows uses powershell tool instead
- */
-
-import { spawn } from 'child_process';
-import * as fs from 'fs';
-import { ToolDefinition } from '../../../types/index.js';
-import { LLMSimpleTool, ToolResult, ToolCategory } from '../../types.js';
-import { logger } from '../../../utils/logger.js';
-import { isNativeWindows, isDangerousBashCommand } from '../../../utils/platform-utils.js';
-import { filterSafeEnv } from '../../../utils/env-filter.js';
-import { configManager } from '../../../core/config/config-manager.js';
-
-/**
- * Execute bash command (WSL/Linux only)
- */
-async function executeBash(
-  command: string,
-  cwd?: string,
-  timeout: number = 30000,
-  explicitEnv?: Record<string, string>
-): Promise<{ stdout: string; stderr: string; exitCode: number }> {
-  return new Promise((resolve, reject) => {
-    // Always use bash on WSL/Linux
-    const shell = '/bin/bash';
-    const shellArgs = ['-c', command];
-
-    // Get user-configured safe env vars
-    const userSafeVars = configManager.getSafeEnvVars();
-
-    const child = spawn(shell, shellArgs, {
-      cwd: cwd || process.cwd(),
-      env: filterSafeEnv(process.env, userSafeVars, explicitEnv || {}), // Merge: filtered process.env + user config + explicit vars
-    });
-
-    let stdout = '';
-    let stderr = '';
-    let killed = false;
-
-    child.stdout?.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    child.stderr?.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    child.on('close', (code) => {
-      if (!killed) {
-        resolve({
-          stdout: stdout.trim(),
-          stderr: stderr.trim(),
-          exitCode: code ?? 0,
-        });
-      }
-    });
-
-    child.on('error', (error) => {
-      reject(error);
-    });
-
-    // Timeout handling
-    const timer = setTimeout(() => {
-      killed = true;
-      child.kill('SIGTERM');
-      reject(new Error(`Command timed out after ${timeout}ms`));
-    }, timeout);
-
-    child.on('close', () => {
-      clearTimeout(timer);
-    });
-  });
-}
-
-/**
- * Bash Tool Definition
- */
-const BASH_TOOL_DEFINITION: ToolDefinition = {
-  type: 'function',
-  function: {
-    name: 'bash',
-    description: `Execute a shell command. Use this to run terminal commands like git, npm, docker, python, etc.
-
-IMPORTANT:
-- Do NOT use for file reading/writing - use read_file, create_file, edit_file instead
-- Commands have a 30 second timeout by default
-- Dangerous commands (rm -rf /, sudo rm, etc.) are blocked
-- Output is truncated if too long`,
-    parameters: {
-      type: 'object',
-      properties: {
-        reason: {
-          type: 'string',
-          description: `A natural, conversational explanation for the user about what you're doing (in user's language).
-Write as if you're talking to the user directly.
-Examples:
-- "Installing project dependencies"
-- "Running tests to check the results"
-- "Checking git status"
-- "Running the build"`,
-        },
-        command: {
-          type: 'string',
-          description: 'The shell command to execute',
-        },
-        cwd: {
-          type: 'string',
-          description: 'Working directory for the command (optional, defaults to current directory)',
-        },
-        timeout: {
-          type: 'number',
-          description: 'Timeout in milliseconds (optional, default: 30000)',
-        },
-        env: {
-          type: 'object',
-          description: 'Environment variables to set for this command (optional). These will be merged with safe system env vars.',
-          additionalProperties: {
-            type: 'string',
-          },
-        },
-      },
-      required: ['reason', 'command'],
-    },
-  },
-};
-
-/**
- * Bash Tool (LLM Simple)
- */
-export const bashTool: LLMSimpleTool = {
-  definition: BASH_TOOL_DEFINITION,
-  categories: ['llm-simple'] as ToolCategory[],
-
-  async execute(args: Record<string, unknown>): Promise<ToolResult> {
-    const command = args['command'] as string;
-    const cwd = args['cwd'] as string | undefined;
-    const timeout = (args['timeout'] as number) || 30000;
-    const env = args['env'] as Record<string, string> | undefined;
-
-    logger.enter('bashTool.execute', { command, cwd, timeout, envKeys: env ? Object.keys(env) : [] });
-
-    // Check platform - should only run on WSL/Linux
-    if (isNativeWindows()) {
-      return {
-        success: false,
-        error: 'bash tool is not available on Native Windows. Use powershell instead.',
-      };
-    }
-
-    // Validate command
-    if (!command || typeof command !== 'string') {
-      return {
-        success: false,
-        error: 'command is required and must be a string',
-      };
-    }
-
-    // Check for dangerous commands
-    if (isDangerousBashCommand(command)) {
-      logger.warn('Dangerous command blocked', { command });
-      return {
-        success: false,
-        error: 'This command is blocked for safety reasons',
-      };
-    }
-
-    // Validate cwd exists and is a directory
-    if (cwd) {
-      if (!fs.existsSync(cwd)) {
-        logger.warn('Invalid cwd provided (does not exist)', { cwd });
-        return {
-          success: false,
-          error: `Working directory does not exist: ${cwd}`,
-        };
-      }
-      if (!fs.statSync(cwd).isDirectory()) {
-        logger.warn('Invalid cwd provided (not a directory)', { cwd });
-        return {
-          success: false,
-          error: `Working directory path is not a directory: ${cwd}`,
-        };
-      }
-    }
-
-    try {
-      const execResult = await executeBash(command, cwd, timeout, env);
-
-      // Combine output
-      let output = '';
-      if (execResult.stdout) {
-        output += execResult.stdout;
-      }
-      if (execResult.stderr) {
-        output += (output ? '\n\n' : '') + `stderr:\n${execResult.stderr}`;
-      }
-
-      // Truncate if too long
-      const MAX_OUTPUT_LENGTH = 50000;
-      if (output.length > MAX_OUTPUT_LENGTH) {
-        output = output.slice(0, MAX_OUTPUT_LENGTH) + '\n\n... [output truncated]';
-      }
-
-      // Add exit code if non-zero
-      if (execResult.exitCode !== 0) {
-        output += `\n\n[Exit code: ${execResult.exitCode}]`;
-      }
-
-      logger.exit('bashTool.execute', { exitCode: execResult.exitCode, outputLength: output.length });
-
-      // Return with error field when command fails
-      if (execResult.exitCode !== 0) {
-        return {
-          success: false,
-          error: output || '(no output)',
-        };
-      }
-
-      return {
-        success: true,
-        result: output || '(no output)',
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error('bashTool.execute failed', error as Error);
-
-      return {
-        success: false,
-        error: `Error executing command: ${errorMessage}`,
-      };
-    }
-  },
-};
-
-export default bashTool;