claudehq 1.0.1 → 1.0.3

package/lib/orchestration/executor.js

@@ -0,0 +1,635 @@
+/**
+ * Orchestration Executor - Manages agent spawning and execution
+ *
+ * Handles spawning Claude agents via tmux, managing their lifecycle,
+ * and coordinating execution based on dependency graphs.
+ */
+
+const { execFile } = require('child_process');
+const crypto = require('crypto');
+const path = require('path');
+const fs = require('fs');
+
+const { AGENT_STATUS, ORCHESTRATION_STATUS } = require('../core/config');
+const { eventBus, EventTypes } = require('../core/event-bus');
+const { broadcastUpdate } = require('../core/sse');
+const orchestrationData = require('../data/orchestration');
+
+// Track active agent sessions
+const activeAgents = new Map(); // agentId -> { tmuxSession, orchestrationId }
+
+/**
+ * Generate a unique tmux session name for an agent
+ * @param {string} agentId - Agent ID
+ * @returns {string} Tmux session name
+ */
+function generateTmuxSessionName(agentId) {
+  const shortId = crypto.randomBytes(3).toString('hex');
+  return `orch-${agentId.slice(-8)}-${shortId}`;
+}
+
+/**
+ * Build the claude command with appropriate flags
+ * @param {Object} agent - Agent configuration
+ * @returns {string} Claude command string
+ */
+function buildClaudeCommand(agent) {
+  const args = [];
+
+  // Model selection
+  if (agent.model && agent.model !== 'sonnet') {
+    args.push(`--model ${agent.model}`);
+  }
+
+  // Always continue conversation if available
+  args.push('-c');
+
+  // Skip permissions for orchestrated agents (they're managed)
+  args.push('--dangerously-skip-permissions');
+
+  // If there's an initial prompt, use -p flag for headless mode initially
+  // then switch to interactive
+  if (agent.prompt) {
+    // We'll send the prompt after spawning
+  }
+
+  return `claude ${args.join(' ')}`;
+}
+
+/**
+ * Spawn an agent in a new tmux window
+ * @param {string} orchestrationId - Orchestration ID
+ * @param {string} agentId - Agent ID
+ * @returns {Promise<Object>} Result with session info or error
+ */
+async function spawnAgent(orchestrationId, agentId) {
+  const agent = orchestrationData.getAgent(orchestrationId, agentId);
+
+  if (!agent) {
+    return { error: 'Agent not found' };
+  }
+
+  if (agent.status !== AGENT_STATUS.PENDING) {
+    return { error: `Agent is not in pending state (current: ${agent.status})` };
+  }
+
+  // Check dependencies
+  const orchestration = orchestrationData.getOrchestration(orchestrationId);
+  for (const depId of agent.dependencies) {
+    const depAgent = orchestration.agents.find(a => a.id === depId);
+    if (!depAgent || depAgent.status !== AGENT_STATUS.COMPLETED) {
+      return { error: `Dependency ${depId} is not completed` };
+    }
+  }
+
+  // Update status to spawning
+  orchestrationData.updateAgent(orchestrationId, agentId, {
+    status: AGENT_STATUS.SPAWNING
+  });
+
+  const tmuxSessionName = generateTmuxSessionName(agentId);
+  const cwd = agent.workingDirectory || process.cwd();
+
+  // Ensure working directory exists
+  if (!fs.existsSync(cwd)) {
+    orchestrationData.updateAgent(orchestrationId, agentId, {
+      status: AGENT_STATUS.FAILED,
+      error: `Working directory does not exist: ${cwd}`
+    });
+    return { error: `Working directory does not exist: ${cwd}` };
+  }
+
+  const claudeCmd = buildClaudeCommand(agent);
+
+  return new Promise((resolve) => {
+    execFile('tmux', [
+      'new-session', '-d', '-s', tmuxSessionName, '-c', cwd, claudeCmd
+    ], (error) => {
+      if (error) {
+        console.error(`Failed to spawn agent ${agentId}: ${error.message}`);
+        orchestrationData.updateAgent(orchestrationId, agentId, {
+          status: AGENT_STATUS.FAILED,
+          error: `Failed to spawn: ${error.message}`
+        });
+        resolve({ error: error.message });
+        return;
+      }
+
+      // Track the active agent
+      activeAgents.set(agentId, {
+        tmuxSession: tmuxSessionName,
+        orchestrationId
+      });
+
+      // Update agent with tmux session info
+      orchestrationData.updateAgent(orchestrationId, agentId, {
+        status: AGENT_STATUS.RUNNING,
+        tmuxWindow: tmuxSessionName,
+        startedAt: new Date().toISOString()
+      });
+
+      console.log(`  Spawned agent "${agent.name}" (${agentId.slice(-8)}) -> tmux:${tmuxSessionName}`);
+
+      // If there's an initial prompt, send it after a short delay
+      if (agent.prompt) {
+        setTimeout(() => {
+          sendPromptToAgent(orchestrationId, agentId, agent.prompt);
+        }, 1000);
+      }
+
+      resolve({
+        success: true,
+        tmuxSession: tmuxSessionName,
+        agentId
+      });
+    });
+  });
+}
+
+/**
+ * Send a prompt to an agent
+ * @param {string} orchestrationId - Orchestration ID
+ * @param {string} agentId - Agent ID
+ * @param {string} prompt - Prompt text
+ * @returns {Promise<Object>} Result
+ */
+async function sendPromptToAgent(orchestrationId, agentId, prompt) {
+  const agentInfo = activeAgents.get(agentId);
+
+  if (!agentInfo) {
+    return { error: 'Agent not found or not running' };
+  }
+
+  return new Promise((resolve, reject) => {
+    const tempFile = `/tmp/orch-prompt-${Date.now()}.txt`;
+    fs.writeFileSync(tempFile, prompt);
+
+    execFile('tmux', ['load-buffer', tempFile], (err) => {
+      if (err) {
+        fs.unlinkSync(tempFile);
+        return resolve({ error: `tmux load-buffer failed: ${err.message}` });
+      }
+
+      execFile('tmux', ['paste-buffer', '-t', agentInfo.tmuxSession], (err2) => {
+        fs.unlinkSync(tempFile);
+
+        if (err2) {
+          return resolve({ error: `tmux paste-buffer failed: ${err2.message}` });
+        }
+
+        setTimeout(() => {
+          execFile('tmux', ['send-keys', '-t', agentInfo.tmuxSession, 'Enter'], (err3) => {
+            if (err3) {
+              return resolve({ error: `tmux send-keys failed: ${err3.message}` });
+            }
+
+            eventBus.emit(EventTypes.AGENT_OUTPUT, {
+              orchestrationId,
+              agentId,
+              type: 'prompt_sent',
+              prompt
+            });
+
+            resolve({ success: true });
+          });
+        }, 50);
+      });
+    });
+  });
+}
+
+/**
+ * Kill an agent
+ * @param {string} orchestrationId - Orchestration ID
+ * @param {string} agentId - Agent ID
+ * @returns {Promise<Object>} Result
+ */
+async function killAgent(orchestrationId, agentId) {
+  const agentInfo = activeAgents.get(agentId);
+
+  if (!agentInfo) {
+    // Agent may not be spawned yet, just update status
+    orchestrationData.updateAgent(orchestrationId, agentId, {
+      status: AGENT_STATUS.CANCELLED,
+      completedAt: new Date().toISOString()
+    });
+    return { success: true };
+  }
+
+  return new Promise((resolve) => {
+    execFile('tmux', ['kill-session', '-t', agentInfo.tmuxSession], (error) => {
+      if (error) {
+        console.log(`  Note: tmux session ${agentInfo.tmuxSession} may already be dead`);
+      }
+
+      activeAgents.delete(agentId);
+
+      orchestrationData.updateAgent(orchestrationId, agentId, {
+        status: AGENT_STATUS.CANCELLED,
+        completedAt: new Date().toISOString()
+      });
+
+      console.log(`  Killed agent ${agentId.slice(-8)}`);
+      resolve({ success: true });
+    });
+  });
+}
+
+/**
+ * Mark an agent as completed
+ * @param {string} orchestrationId - Orchestration ID
+ * @param {string} agentId - Agent ID
+ * @param {Object} result - Optional result data
+ * @returns {Object} Result
+ */
+function completeAgent(orchestrationId, agentId, result = {}) {
+  activeAgents.delete(agentId);
+
+  orchestrationData.updateAgent(orchestrationId, agentId, {
+    status: AGENT_STATUS.COMPLETED,
+    completedAt: new Date().toISOString(),
+    output: result.output || null
+  });
+
+  // Check if any dependent agents can now run
+  checkAndSpawnReadyAgents(orchestrationId);
+
+  // Check if orchestration is complete
+  if (orchestrationData.isOrchestrationComplete(orchestrationId)) {
+    orchestrationData.updateOrchestration(orchestrationId, {
+      status: ORCHESTRATION_STATUS.COMPLETED,
+      completedAt: new Date().toISOString()
+    });
+  }
+
+  return { success: true };
+}
+
+/**
+ * Mark an agent as failed
+ * @param {string} orchestrationId - Orchestration ID
+ * @param {string} agentId - Agent ID
+ * @param {string} error - Error message
+ * @returns {Object} Result
+ */
+function failAgent(orchestrationId, agentId, error) {
+  activeAgents.delete(agentId);
+
+  orchestrationData.updateAgent(orchestrationId, agentId, {
+    status: AGENT_STATUS.FAILED,
+    completedAt: new Date().toISOString(),
+    error
+  });
+
+  // Check if orchestration should fail
+  const orchestration = orchestrationData.getOrchestration(orchestrationId);
+  const failOnError = orchestration.metadata?.failOnError !== false;
+
+  if (failOnError) {
+    // Mark orchestration as failed
+    orchestrationData.updateOrchestration(orchestrationId, {
+      status: ORCHESTRATION_STATUS.FAILED,
+      completedAt: new Date().toISOString()
+    });
+  } else {
+    // Continue with other agents
+    checkAndSpawnReadyAgents(orchestrationId);
+
+    if (orchestrationData.isOrchestrationComplete(orchestrationId)) {
+      orchestrationData.updateOrchestration(orchestrationId, {
+        status: ORCHESTRATION_STATUS.COMPLETED,
+        completedAt: new Date().toISOString()
+      });
+    }
+  }
+
+  return { success: true };
+}
+
+/**
+ * Check for agents ready to run and spawn them
+ * @param {string} orchestrationId - Orchestration ID
+ */
+async function checkAndSpawnReadyAgents(orchestrationId) {
+  const orchestration = orchestrationData.getOrchestration(orchestrationId);
+
+  if (!orchestration || orchestration.status !== ORCHESTRATION_STATUS.RUNNING) {
+    return;
+  }
+
+  const readyAgents = orchestrationData.getReadyAgents(orchestrationId);
+
+  for (const agent of readyAgents) {
+    console.log(`  Auto-spawning ready agent: ${agent.name}`);
+    await spawnAgent(orchestrationId, agent.id);
+  }
+}
+
+/**
+ * Start an orchestration (spawn all ready agents)
+ * @param {string} orchestrationId - Orchestration ID
+ * @returns {Promise<Object>} Result
+ */
+async function startOrchestration(orchestrationId) {
+  const orchestration = orchestrationData.getOrchestration(orchestrationId);
+
+  if (!orchestration) {
+    return { error: 'Orchestration not found' };
+  }
+
+  if (orchestration.status === ORCHESTRATION_STATUS.RUNNING) {
+    return { error: 'Orchestration is already running' };
+  }
+
+  if (orchestration.status === ORCHESTRATION_STATUS.COMPLETED) {
+    return { error: 'Orchestration is already completed' };
+  }
+
+  if (orchestration.agents.length === 0) {
+    return { error: 'Orchestration has no agents' };
+  }
+
+  // Update orchestration status
+  orchestrationData.updateOrchestration(orchestrationId, {
+    status: ORCHESTRATION_STATUS.RUNNING,
+    startedAt: new Date().toISOString()
+  });
+
+  // Spawn all ready agents (those with no dependencies or all deps completed)
+  const readyAgents = orchestrationData.getReadyAgents(orchestrationId);
+
+  if (readyAgents.length === 0) {
+    return { error: 'No agents are ready to run (check dependencies)' };
+  }
+
+  console.log(`  Starting orchestration "${orchestration.name}" with ${readyAgents.length} ready agents`);
+
+  const results = [];
+  for (const agent of readyAgents) {
+    const result = await spawnAgent(orchestrationId, agent.id);
+    results.push({ agentId: agent.id, ...result });
+  }
+
+  return {
+    success: true,
+    orchestrationId,
+    spawnedAgents: results.filter(r => r.success).length,
+    results
+  };
+}
+
+/**
+ * Stop an orchestration (kill all running agents)
+ * @param {string} orchestrationId - Orchestration ID
+ * @returns {Promise<Object>} Result
+ */
+async function stopOrchestration(orchestrationId) {
+  const orchestration = orchestrationData.getOrchestration(orchestrationId);
+
+  if (!orchestration) {
+    return { error: 'Orchestration not found' };
+  }
+
+  console.log(`  Stopping orchestration "${orchestration.name}"`);
+
+  // Kill all running/spawning agents
+  const runningAgents = orchestration.agents.filter(a =>
+    a.status === AGENT_STATUS.RUNNING || a.status === AGENT_STATUS.SPAWNING
+  );
+
+  for (const agent of runningAgents) {
+    await killAgent(orchestrationId, agent.id);
+  }
+
+  // Mark pending agents as cancelled
+  const pendingAgents = orchestration.agents.filter(a => a.status === AGENT_STATUS.PENDING);
+  for (const agent of pendingAgents) {
+    orchestrationData.updateAgent(orchestrationId, agent.id, {
+      status: AGENT_STATUS.CANCELLED
+    });
+  }
+
+  // Update orchestration status
+  orchestrationData.updateOrchestration(orchestrationId, {
+    status: ORCHESTRATION_STATUS.PAUSED
+  });
+
+  return {
+    success: true,
+    killedAgents: runningAgents.length,
+    cancelledAgents: pendingAgents.length
+  };
+}
+
+/**
+ * Check health of all active agents
+ */
+function checkAgentHealth() {
+  execFile('tmux', ['list-sessions', '-F', '#{session_name}'], (error, stdout) => {
+    if (error) {
+      // No tmux sessions - mark all agents as offline/failed
+      for (const [agentId, info] of activeAgents) {
+        console.log(`  Agent ${agentId.slice(-8)} tmux session died`);
+        failAgent(info.orchestrationId, agentId, 'Tmux session died');
+      }
+      return;
+    }
+
+    const activeSessions = new Set(stdout.trim().split('\n').filter(Boolean));
+
+    for (const [agentId, info] of activeAgents) {
+      if (!activeSessions.has(info.tmuxSession)) {
+        console.log(`  Agent ${agentId.slice(-8)} tmux session no longer exists`);
+        // Session died - this could mean the agent completed or crashed
+        // For now, mark as completed (user can check output)
+        completeAgent(info.orchestrationId, agentId, {
+          output: 'Session ended'
+        });
+      }
+    }
+  });
+}
+
+/**
+ * Get status of an agent's tmux session
+ * @param {string} agentId - Agent ID
+ * @returns {Promise<Object>} Status info
+ */
+async function getAgentTmuxStatus(agentId) {
+  const agentInfo = activeAgents.get(agentId);
+
+  if (!agentInfo) {
+    return { active: false };
+  }
+
+  return new Promise((resolve) => {
+    execFile('tmux', ['capture-pane', '-t', agentInfo.tmuxSession, '-p', '-S', '-30'],
+      { timeout: 2000, maxBuffer: 1024 * 1024 },
+      (error, stdout) => {
+        if (error) {
+          resolve({ active: false, error: error.message });
+          return;
+        }
+
+        resolve({
+          active: true,
+          tmuxSession: agentInfo.tmuxSession,
+          recentOutput: stdout
+        });
+      }
+    );
+  });
+}
+
+/**
+ * Link a Claude session event to an orchestration agent
+ * @param {string} claudeSessionId - Claude session ID from hook event
+ * @param {string} orchestrationId - Orchestration ID
+ * @param {string} agentId - Agent ID
+ */
+function linkClaudeSessionToAgent(claudeSessionId, orchestrationId, agentId) {
+  orchestrationData.updateAgent(orchestrationId, agentId, {
+    sessionId: claudeSessionId
+  });
+}
+
+/**
+ * Find agent by Claude session ID
+ * @param {string} claudeSessionId - Claude session ID
+ * @returns {Object|null} Agent info or null
+ */
+function findAgentByClaudeSession(claudeSessionId) {
+  const orchestrations = orchestrationData.listOrchestrations();
+
+  for (const orch of orchestrations) {
+    for (const agent of orch.agents) {
+      if (agent.sessionId === claudeSessionId) {
+        return { orchestrationId: orch.id, agent };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Start health check interval
+ */
+let healthCheckInterval = null;
+
+function startHealthChecks() {
+  if (healthCheckInterval) {
+    clearInterval(healthCheckInterval);
+  }
+  healthCheckInterval = setInterval(checkAgentHealth, 5000);
+  console.log('  Orchestration health monitoring started (5s interval)');
+}
+
+function stopHealthChecks() {
+  if (healthCheckInterval) {
+    clearInterval(healthCheckInterval);
+    healthCheckInterval = null;
+  }
+}
+
+// Register event handlers for SSE broadcasts
+function registerEventHandlers() {
+  // Orchestration events
+  eventBus.on(EventTypes.ORCHESTRATION_CREATED, (data) => {
+    broadcastUpdate('orchestration_created', data);
+  });
+
+  eventBus.on(EventTypes.ORCHESTRATION_UPDATED, (data) => {
+    broadcastUpdate('orchestration_updated', data);
+  });
+
+  eventBus.on(EventTypes.ORCHESTRATION_STARTED, (data) => {
+    broadcastUpdate('orchestration_started', data);
+  });
+
+  eventBus.on(EventTypes.ORCHESTRATION_COMPLETED, (data) => {
+    broadcastUpdate('orchestration_completed', data);
+  });
+
+  eventBus.on(EventTypes.ORCHESTRATION_FAILED, (data) => {
+    broadcastUpdate('orchestration_failed', data);
+  });
+
+  eventBus.on(EventTypes.ORCHESTRATION_PAUSED, (data) => {
+    broadcastUpdate('orchestration_paused', data);
+  });
+
+  eventBus.on(EventTypes.ORCHESTRATION_DELETED, (data) => {
+    broadcastUpdate('orchestration_deleted', data);
+  });
+
+  // Agent events
+  eventBus.on(EventTypes.AGENT_CREATED, (data) => {
+    broadcastUpdate('agent_created', data);
+  });
+
+  eventBus.on(EventTypes.AGENT_SPAWNED, (data) => {
+    broadcastUpdate('agent_spawned', data);
+  });
+
+  eventBus.on(EventTypes.AGENT_STATUS_CHANGED, (data) => {
+    broadcastUpdate('agent_status_changed', data);
+  });
+
+  eventBus.on(EventTypes.AGENT_OUTPUT, (data) => {
+    broadcastUpdate('agent_output', data);
+  });
+
+  eventBus.on(EventTypes.AGENT_COMPLETED, (data) => {
+    broadcastUpdate('agent_completed', data);
+  });
+
+  eventBus.on(EventTypes.AGENT_FAILED, (data) => {
+    broadcastUpdate('agent_failed', data);
+  });
+
+  eventBus.on(EventTypes.AGENT_KILLED, (data) => {
+    broadcastUpdate('agent_killed', data);
+  });
+
+  console.log('  Orchestration event handlers registered');
+}
+
+/**
+ * Initialize the executor
+ */
+function init() {
+  registerEventHandlers();
+  startHealthChecks();
+}
+
+module.exports = {
+  // Initialization
+  init,
+  startHealthChecks,
+  stopHealthChecks,
+  registerEventHandlers,
+
+  // Agent lifecycle
+  spawnAgent,
+  killAgent,
+  completeAgent,
+  failAgent,
+  sendPromptToAgent,
+
+  // Orchestration lifecycle
+  startOrchestration,
+  stopOrchestration,
+  checkAndSpawnReadyAgents,
+
+  // Status
+  getAgentTmuxStatus,
+  checkAgentHealth,
+
+  // Session linking
+  linkClaudeSessionToAgent,
+  findAgentByClaudeSession,
+
+  // Direct access
+  activeAgents
+};