orquesta-cli 0.1.12

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

@@ -0,0 +1,421 @@
+/**
+ * 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

@@ -0,0 +1,238 @@
+/**
+ * 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;