teleportation-cli 1.1.4 → 1.2.0

package/lib/daemon/agentic-executor.js

@@ -1,803 +0,0 @@
-/**
- * Agentic Executor
- *
- * Executes agentic tasks using Claude Code's headless mode.
- * Provides an autonomous execution loop that continues until:
- * - Task is complete
- * - Claude asks a question requiring user input
- * - User stops the task
- * - Budget is exhausted
- *
- * Key features:
- * - Uses `claude -p` with `--output-format json` for structured results
- * - Captures `session_id` from JSON result for conversation continuity
- * - Uses `--resume <session-id>` for subsequent turns
- * - Budget control via `--max-budget-usd`
- * - Auto-approval via `--permission-mode bypassPermissions`
- *
- * @module lib/daemon/agentic-executor
- */
-
-import { spawn } from 'child_process';
-import { randomUUID } from 'crypto';
-import { classifyResponse, getConfidenceThreshold } from './response-classifier.js';
-
-// Default configuration
-const DEFAULT_BUDGET_USD = 10.0;
-const DEFAULT_TIMEOUT_MS = 600000; // 10 minutes per turn
-const CLAUDE_CLI = process.env.CLAUDE_CLI_PATH || 'claude';
-
-// Safety limits to prevent runaway execution
-const MAX_TURNS = 100; // Maximum execution turns before forced stop
-const WAIT_FOR_RESUME_TIMEOUT_MS = 1800000; // 30 minutes max wait for resume
-const POLLING_INTERVAL_MS = 1000; // Polling interval for waitForResume
-const SESSION_CLEANUP_INTERVAL_MS = 300000; // 5 minutes cleanup interval
-const SESSION_MAX_AGE_MS = 3600000; // 1 hour max session age
-const MAX_CONSECUTIVE_FAILURES = 3; // Stop after this many consecutive failures
-const MAX_HISTORY_SIZE = 20; // Maximum history entries to keep per session
-
-/**
- * Agentic session state
- * @typedef {Object} AgenticSession
- * @property {string} id - Unique session ID
- * @property {string} task - Original task description
- * @property {'running' | 'paused' | 'waiting_input' | 'completed' | 'stopped' | 'budget_paused'} status
- * @property {string|null} claude_session_id - Claude Code's session ID for resume
- * @property {number} budget_usd - Total budget allocated
- * @property {number} cost_usd - Total cost incurred so far
- * @property {number} started_at - Timestamp when task started
- * @property {number} updated_at - Timestamp of last update
- * @property {number|null} completed_at - Timestamp when task completed
- * @property {string|null} pending_question - Question waiting for user answer
- * @property {number} turn_count - Number of execution turns
- * @property {Array} history - Execution history
- */
-
-// In-memory session store (will be replaced with Redis in relay endpoints)
-const agenticSessions = new Map();
-
-// Track running processes for stop functionality
-const runningProcesses = new Map();
-
-/**
- * Cleanup old/stale sessions to prevent memory leaks
- * Removes sessions that:
- * - Are completed/stopped and older than SESSION_MAX_AGE_MS
- * - Have no activity for SESSION_MAX_AGE_MS
- */
-function cleanupStaleSessions() {
-  const now = Date.now();
-  let cleanedCount = 0;
-
-  for (const [id, session] of agenticSessions) {
-    const age = now - session.started_at;
-    const lastActivity = now - session.updated_at;
-
-    // Remove finished sessions older than max age
-    const isFinished = session.status === 'completed' || session.status === 'stopped';
-    if (isFinished && age > SESSION_MAX_AGE_MS) {
-      agenticSessions.delete(id);
-      runningProcesses.delete(id);
-      cleanedCount++;
-      continue;
-    }
-
-    // Remove sessions with no activity for max age
-    if (lastActivity > SESSION_MAX_AGE_MS) {
-      // Kill any running process
-      const proc = runningProcesses.get(id);
-      if (proc) {
-        proc.kill('SIGTERM');
-        runningProcesses.delete(id);
-      }
-      agenticSessions.delete(id);
-      cleanedCount++;
-    }
-  }
-
-  if (cleanedCount > 0) {
-    console.log(`[agentic] Cleaned up ${cleanedCount} stale sessions`);
-  }
-}
-
-// Start periodic cleanup (only in non-test environments)
-if (process.env.NODE_ENV !== 'test') {
-  setInterval(cleanupStaleSessions, SESSION_CLEANUP_INTERVAL_MS);
-}
-
-/**
- * Generate a unique agentic session ID using cryptographically secure random UUID
- * @returns {string}
- */
-function generateAgenticId() {
-  return `agentic-${Date.now()}-${randomUUID()}`;
-}
-
-/**
- * Execute Claude Code in headless mode
- *
- * @param {Object} options
- * @param {string} options.prompt - The prompt to send to Claude
- * @param {string} options.cwd - Working directory
- * @param {string|null} options.resumeSessionId - Claude session ID to resume (null for new)
- * @param {number} options.budgetUsd - Max budget in USD
- * @param {number} options.timeoutMs - Timeout in milliseconds
- * @param {string} options.agenticId - Agentic session ID for tracking
- * @returns {Promise<Object>} Execution result with session_id, output, cost, etc.
- */
-async function executeClaudeHeadless(options) {
-  const {
-    prompt,
-    cwd,
-    resumeSessionId,
-    budgetUsd,
-    timeoutMs = DEFAULT_TIMEOUT_MS,
-    agenticId,
-  } = options;
-
-  return new Promise((resolve, reject) => {
-    const args = [];
-
-    // Resume existing session or start new
-    if (resumeSessionId) {
-      args.push('--resume', resumeSessionId);
-    }
-
-    // Add prompt
-    args.push('-p', prompt);
-
-    // Output format for structured parsing
-    args.push('--output-format', 'json');
-
-    // Budget control (Claude Code native feature)
-    if (budgetUsd > 0) {
-      args.push('--max-budget-usd', budgetUsd.toFixed(2));
-    }
-
-    // Auto-approval mode
-    args.push('--permission-mode', 'bypassPermissions');
-
-    console.log(`[agentic] Executing: ${CLAUDE_CLI} ${args.join(' ')}`);
-
-    const proc = spawn(CLAUDE_CLI, args, {
-      cwd,
-      stdio: 'pipe',
-      env: {
-        ...process.env,
-        CI: 'true', // Non-interactive mode
-        TELEPORTATION_AGENTIC_MODE: 'true',
-      },
-    });
-
-    // Track process for stop functionality
-    runningProcesses.set(agenticId, proc);
-
-    // Close stdin to prevent hanging
-    proc.stdin.end();
-
-    let stdout = '';
-    let stderr = '';
-    let timedOut = false;
-
-    // Timeout handler
-    const timeout = setTimeout(() => {
-      timedOut = true;
-      proc.kill('SIGTERM');
-    }, timeoutMs);
-
-    proc.stdout.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    proc.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    proc.on('close', (code) => {
-      clearTimeout(timeout);
-      runningProcesses.delete(agenticId);
-
-      if (timedOut) {
-        resolve({
-          success: false,
-          output: stdout,
-          error: 'Execution timed out',
-          exit_code: -1,
-          session_id: null,
-          cost_usd: 0,
-          duration_ms: timeoutMs,
-        });
-        return;
-      }
-
-      // Parse JSON result to extract session_id and other metadata
-      let result = {
-        success: code === 0,
-        output: stdout,
-        error: code !== 0 ? stderr || `Exit code: ${code}` : null,
-        exit_code: code,
-        session_id: null,
-        cost_usd: 0,
-        duration_ms: 0,
-        model: null,
-        usage: null,
-      };
-
-      try {
-        // Claude outputs JSON when using --output-format json
-        const parsed = JSON.parse(stdout);
-
-        result.output = parsed.result || parsed.response || parsed.output || stdout;
-        result.session_id = parsed.session_id || null;
-        result.cost_usd = parsed.cost || parsed.total_cost_usd || 0;
-        result.duration_ms = parsed.duration_ms || 0;
-        result.model = parsed.model || null;
-        result.usage = parsed.usage || null;
-
-        // Handle error responses
-        if (parsed.is_error) {
-          result.success = false;
-          result.error = parsed.error || 'Unknown error';
-        }
-      } catch {
-        // If JSON parsing fails, use raw stdout
-        // Try to extract session_id from text output if present
-        const sessionMatch = stdout.match(/session_id["\s:]+([a-zA-Z0-9_-]+)/i);
-        if (sessionMatch) {
-          result.session_id = sessionMatch[1];
-        }
-      }
-
-      resolve(result);
-    });
-
-    proc.on('error', (err) => {
-      clearTimeout(timeout);
-      runningProcesses.delete(agenticId);
-      reject(err);
-    });
-  });
-}
-
-/**
- * Start a new agentic task
- *
- * @param {Object} options
- * @param {string} options.task - Task description
- * @param {string} options.session_id - Teleportation session ID
- * @param {string} options.cwd - Working directory
- * @param {number} [options.budget_usd] - Max budget in USD (default: 10)
- * @param {Function} [options.onEvent] - Callback for agentic events
- * @returns {Promise<AgenticSession>}
- */
-export async function startAgenticTask(options) {
-  const {
-    task,
-    session_id,
-    cwd,
-    budget_usd = DEFAULT_BUDGET_USD,
-    onEvent,
-  } = options;
-
-  const agenticId = generateAgenticId();
-  const now = Date.now();
-
-  // Create agentic session
-  const session = {
-    id: agenticId,
-    teleportation_session_id: session_id,
-    task,
-    status: 'running',
-    claude_session_id: null,
-    budget_usd,
-    cost_usd: 0,
-    started_at: now,
-    updated_at: now,
-    completed_at: null,
-    pending_question: null,
-    turn_count: 0,
-    history: [],
-    cwd,
-  };
-
-  agenticSessions.set(agenticId, session);
-
-  // Emit started event
-  if (onEvent) {
-    onEvent({
-      type: 'agentic_started',
-      agentic_id: agenticId,
-      session_id,
-      task,
-      budget_usd,
-      timestamp: now,
-    });
-  }
-
-  // Start execution loop
-  executeAgenticLoop(agenticId, onEvent).catch(err => {
-    console.error(`[agentic] Loop error for ${agenticId}:`, err.message);
-    const s = agenticSessions.get(agenticId);
-    if (s) {
-      s.status = 'stopped';
-      s.updated_at = Date.now();
-      if (onEvent) {
-        onEvent({
-          type: 'agentic_stopped',
-          agentic_id: agenticId,
-          reason: `Error: ${err.message}`,
-          timestamp: Date.now(),
-        });
-      }
-    }
-  });
-
-  return session;
-}
-
-/**
- * Main agentic execution loop
- * Continues until complete, question, stopped, or budget exhausted
- *
- * @param {string} agenticId - Agentic session ID
- * @param {Function} onEvent - Event callback
- */
-async function executeAgenticLoop(agenticId, onEvent) {
-  const session = agenticSessions.get(agenticId);
-  if (!session) {
-    throw new Error(`Agentic session not found: ${agenticId}`);
-  }
-
-  let continueExecution = true;
-  let consecutiveFailures = 0;
-
-  while (continueExecution) {
-    // Check for stop signal
-    if (session.status === 'stopped') {
-      console.log(`[agentic] Session ${agenticId} stopped by user`);
-      break;
-    }
-
-    // Safety: Check max turns limit to prevent infinite loops
-    if (session.turn_count >= MAX_TURNS) {
-      session.status = 'stopped';
-      session.updated_at = Date.now();
-      console.log(`[agentic] Session ${agenticId} reached max turns limit (${MAX_TURNS})`);
-      if (onEvent) {
-        onEvent({
-          type: 'agentic_stopped',
-          agentic_id: agenticId,
-          reason: `Max turns limit reached (${MAX_TURNS})`,
-          cost_usd: session.cost_usd,
-          turn_count: session.turn_count,
-          timestamp: Date.now(),
-        });
-      }
-      break;
-    }
-
-    // Check for pause
-    if (session.status === 'paused') {
-      console.log(`[agentic] Session ${agenticId} paused, waiting for resume`);
-      try {
-        await waitForResume(agenticId);
-      } catch (timeoutError) {
-        // Timeout occurred - session already marked as stopped in waitForResume
-        console.log(`[agentic] Session ${agenticId} pause timeout: ${timeoutError.message}`);
-        if (onEvent) {
-          onEvent({
-            type: 'agentic_stopped',
-            agentic_id: agenticId,
-            reason: 'Pause timeout - no resume received',
-            timestamp: Date.now(),
-          });
-        }
-        break;
-      }
-      continue;
-    }
-
-    // Check budget
-    const remainingBudget = session.budget_usd - session.cost_usd;
-    if (remainingBudget <= 0) {
-      session.status = 'budget_paused';
-      session.updated_at = Date.now();
-      console.log(`[agentic] Session ${agenticId} budget exhausted`);
-      if (onEvent) {
-        onEvent({
-          type: 'agentic_budget_hit',
-          agentic_id: agenticId,
-          cost_usd: session.cost_usd,
-          budget_usd: session.budget_usd,
-          timestamp: Date.now(),
-        });
-      }
-      break;
-    }
-
-    // Build prompt for this turn
-    const prompt = session.turn_count === 0
-      ? session.task
-      : 'Continue working on the task.';
-
-    // Execute Claude
-    session.turn_count++;
-    console.log(`[agentic] Turn ${session.turn_count} for ${agenticId}`);
-
-    // Re-check status immediately before expensive operation (race condition fix)
-    const currentSession = agenticSessions.get(agenticId);
-    if (!currentSession || currentSession.status === 'stopped') {
-      console.log(`[agentic] Session ${agenticId} stopped before execution`);
-      break;
-    }
-
-    try {
-      const result = await executeClaudeHeadless({
-        prompt,
-        cwd: session.cwd,
-        resumeSessionId: session.claude_session_id,
-        budgetUsd: remainingBudget,
-        agenticId,
-      });
-
-      // Update session with result
-      session.claude_session_id = result.session_id || session.claude_session_id;
-      session.cost_usd += result.cost_usd || 0;
-      session.updated_at = Date.now();
-
-      // Add to history
-      session.history.push({
-        turn: session.turn_count,
-        prompt,
-        output: result.output?.slice(0, 2000), // Truncate for storage
-        cost_usd: result.cost_usd,
-        success: result.success,
-        timestamp: Date.now(),
-      });
-
-      // Trim history to prevent unbounded growth
-      if (session.history.length > MAX_HISTORY_SIZE) {
-        session.history = session.history.slice(-MAX_HISTORY_SIZE);
-      }
-
-      // Track consecutive failures for error recovery
-      if (!result.success) {
-        consecutiveFailures++;
-        console.error(`[agentic] Turn ${session.turn_count} failed (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}):`, result.error);
-
-        if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
-          session.status = 'stopped';
-          session.updated_at = Date.now();
-          console.log(`[agentic] Session ${agenticId} stopped due to ${MAX_CONSECUTIVE_FAILURES} consecutive failures`);
-          if (onEvent) {
-            onEvent({
-              type: 'agentic_stopped',
-              agentic_id: agenticId,
-              reason: `${MAX_CONSECUTIVE_FAILURES} consecutive failures`,
-              cost_usd: session.cost_usd,
-              turn_count: session.turn_count,
-              timestamp: Date.now(),
-            });
-          }
-          break;
-        }
-      } else {
-        // Reset failure counter on success
-        consecutiveFailures = 0;
-      }
-
-      // Classify the response
-      const classification = classifyResponse(result);
-      console.log(`[agentic] Classification: ${classification.action} (confidence: ${classification.confidence})`);
-
-      // Determine next action based on classification
-      switch (classification.action) {
-        case 'complete':
-          session.status = 'completed';
-          session.completed_at = Date.now();
-          session.updated_at = Date.now();
-          continueExecution = false;
-          console.log(`[agentic] Task completed for ${agenticId}`);
-          if (onEvent) {
-            onEvent({
-              type: 'agentic_completed',
-              agentic_id: agenticId,
-              output: result.output,
-              cost_usd: session.cost_usd,
-              turn_count: session.turn_count,
-              timestamp: Date.now(),
-            });
-          }
-          break;
-
-        case 'question':
-          session.status = 'waiting_input';
-          session.pending_question = classification.questionText;
-          session.updated_at = Date.now();
-          continueExecution = false;
-          console.log(`[agentic] Question detected for ${agenticId}: ${classification.questionText?.slice(0, 100)}`);
-          if (onEvent) {
-            onEvent({
-              type: 'agentic_question',
-              agentic_id: agenticId,
-              question: classification.questionText,
-              confidence: classification.confidence,
-              timestamp: Date.now(),
-            });
-          }
-          break;
-
-        case 'continue':
-        default:
-          // Continue working - loop will iterate
-          console.log(`[agentic] Continuing execution for ${agenticId}`);
-          break;
-      }
-    } catch (error) {
-      console.error(`[agentic] Execution error for ${agenticId}:`, error.message);
-      session.status = 'stopped';
-      session.updated_at = Date.now();
-      continueExecution = false;
-      if (onEvent) {
-        onEvent({
-          type: 'agentic_stopped',
-          agentic_id: agenticId,
-          reason: `Error: ${error.message}`,
-          timestamp: Date.now(),
-        });
-      }
-    }
-  }
-}
-
-/**
- * Wait for an agentic session to be resumed
- * @param {string} agenticId
- * @returns {Promise<void>}
- */
-/**
- * Wait for an agentic session to be resumed with timeout protection
- * @param {string} agenticId
- * @param {number} timeoutMs - Maximum wait time (default: 30 minutes)
- * @returns {Promise<void>}
- * @throws {Error} If timeout is reached
- */
-async function waitForResume(agenticId, timeoutMs = WAIT_FOR_RESUME_TIMEOUT_MS) {
-  return new Promise((resolve, reject) => {
-    const startTime = Date.now();
-
-    const checkInterval = setInterval(() => {
-      const session = agenticSessions.get(agenticId);
-
-      // Check for timeout
-      if (Date.now() - startTime > timeoutMs) {
-        clearInterval(checkInterval);
-        console.log(`[agentic] Session ${agenticId} resume timeout after ${timeoutMs}ms`);
-
-        // Mark session as stopped due to timeout
-        if (session) {
-          session.status = 'stopped';
-          session.updated_at = Date.now();
-        }
-
-        reject(new Error(`Resume timeout after ${timeoutMs}ms`));
-        return;
-      }
-
-      // Check if session no longer paused
-      if (!session || session.status !== 'paused') {
-        clearInterval(checkInterval);
-        resolve();
-      }
-    }, POLLING_INTERVAL_MS);
-  });
-}
-
-/**
- * Stop an agentic task
- *
- * @param {string} agenticId - Agentic session ID
- * @returns {{ success: boolean, reason?: string }}
- */
-export function stopAgenticTask(agenticId) {
-  const session = agenticSessions.get(agenticId);
-  if (!session) {
-    return { success: false, reason: 'Session not found' };
-  }
-
-  // Kill running process if any
-  const proc = runningProcesses.get(agenticId);
-  if (proc) {
-    proc.kill('SIGTERM');
-    runningProcesses.delete(agenticId);
-    console.log(`[agentic] Killed process for ${agenticId}`);
-  }
-
-  session.status = 'stopped';
-  session.updated_at = Date.now();
-
-  return { success: true };
-}
-
-/**
- * Pause an agentic task
- *
- * @param {string} agenticId - Agentic session ID
- * @returns {{ success: boolean, reason?: string }}
- */
-export function pauseAgenticTask(agenticId) {
-  const session = agenticSessions.get(agenticId);
-  if (!session) {
-    return { success: false, reason: 'Session not found' };
-  }
-
-  if (session.status !== 'running') {
-    return { success: false, reason: `Cannot pause session in ${session.status} status` };
-  }
-
-  session.status = 'paused';
-  session.updated_at = Date.now();
-
-  return { success: true };
-}
-
-/**
- * Resume a paused agentic task
- *
- * @param {string} agenticId - Agentic session ID
- * @param {Function} [onEvent] - Event callback
- * @returns {{ success: boolean, reason?: string }}
- */
-export function resumeAgenticTask(agenticId, onEvent) {
-  const session = agenticSessions.get(agenticId);
-  if (!session) {
-    return { success: false, reason: 'Session not found' };
-  }
-
-  if (session.status !== 'paused' && session.status !== 'budget_paused') {
-    return { success: false, reason: `Cannot resume session in ${session.status} status` };
-  }
-
-  session.status = 'running';
-  session.updated_at = Date.now();
-
-  // Restart execution loop
-  executeAgenticLoop(agenticId, onEvent).catch(err => {
-    console.error(`[agentic] Resume loop error for ${agenticId}:`, err.message);
-  });
-
-  return { success: true };
-}
-
-/**
- * Answer a question for an agentic task
- *
- * @param {string} agenticId - Agentic session ID
- * @param {string} answer - User's answer to the question
- * @param {Function} [onEvent] - Event callback
- * @returns {{ success: boolean, reason?: string }}
- */
-export async function answerAgenticQuestion(agenticId, answer, onEvent) {
-  const session = agenticSessions.get(agenticId);
-  if (!session) {
-    return { success: false, reason: 'Session not found' };
-  }
-
-  if (session.status !== 'waiting_input') {
-    return { success: false, reason: `Cannot answer question in ${session.status} status` };
-  }
-
-  // Emit user input event
-  if (onEvent) {
-    onEvent({
-      type: 'agentic_user_input',
-      agentic_id: agenticId,
-      question: session.pending_question,
-      answer,
-      timestamp: Date.now(),
-    });
-  }
-
-  // Clear pending question and set status to running
-  session.pending_question = null;
-  session.status = 'running';
-  session.updated_at = Date.now();
-
-  // Execute the next turn with the user's answer
-  const remainingBudget = session.budget_usd - session.cost_usd;
-
-  try {
-    session.turn_count++;
-    const result = await executeClaudeHeadless({
-      prompt: answer,
-      cwd: session.cwd,
-      resumeSessionId: session.claude_session_id,
-      budgetUsd: remainingBudget,
-      agenticId,
-    });
-
-    // Update session
-    session.claude_session_id = result.session_id || session.claude_session_id;
-    session.cost_usd += result.cost_usd || 0;
-    session.updated_at = Date.now();
-
-    // Add to history
-    session.history.push({
-      turn: session.turn_count,
-      prompt: `[User Answer] ${answer}`,
-      output: result.output?.slice(0, 2000),
-      cost_usd: result.cost_usd,
-      success: result.success,
-      timestamp: Date.now(),
-    });
-
-    // Resume the execution loop
-    executeAgenticLoop(agenticId, onEvent).catch(err => {
-      console.error(`[agentic] Answer loop error for ${agenticId}:`, err.message);
-    });
-
-    return { success: true };
-  } catch (error) {
-    session.status = 'stopped';
-    session.updated_at = Date.now();
-    return { success: false, reason: error.message };
-  }
-}
-
-/**
- * Get agentic session status
- *
- * @param {string} agenticId - Agentic session ID
- * @returns {AgenticSession|null}
- */
-export function getAgenticSession(agenticId) {
-  return agenticSessions.get(agenticId) || null;
-}
-
-/**
- * List all agentic sessions for a teleportation session
- *
- * @param {string} session_id - Teleportation session ID
- * @returns {AgenticSession[]}
- */
-export function listAgenticSessions(session_id) {
-  const sessions = [];
-  for (const [, session] of agenticSessions) {
-    if (session.teleportation_session_id === session_id) {
-      sessions.push(session);
-    }
-  }
-  return sessions;
-}
-
-/**
- * Increase budget for an agentic task
- *
- * @param {string} agenticId - Agentic session ID
- * @param {number} additionalBudget - Additional budget in USD
- * @returns {{ success: boolean, new_budget?: number, reason?: string }}
- */
-export function increaseBudget(agenticId, additionalBudget) {
-  const session = agenticSessions.get(agenticId);
-  if (!session) {
-    return { success: false, reason: 'Session not found' };
-  }
-
-  if (additionalBudget <= 0) {
-    return { success: false, reason: 'Additional budget must be positive' };
-  }
-
-  session.budget_usd += additionalBudget;
-  session.updated_at = Date.now();
-
-  return { success: true, new_budget: session.budget_usd };
-}
-
-// Export for testing
-export const __test = {
-  agenticSessions,
-  runningProcesses,
-  executeClaudeHeadless,
-  executeAgenticLoop,
-  generateAgenticId,
-};