teleportation-cli 1.1.5 → 1.2.1

package/lib/daemon/task-executor-v2.js

@@ -0,0 +1,413 @@
+/**
+ * Task Executor V2 - Timeline-Driven Architecture
+ *
+ * Stateless task execution that uses timeline events as source of truth.
+ * Daemon can crash and restart without losing state.
+ *
+ * @module lib/daemon/task-executor-v2
+ */
+
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fetchTimeline, analyzeTaskState, getNextPrompt, shouldStopTask } from './timeline-analyzer.js';
+import { ingestTranscriptToTimeline } from './transcript-ingestion.js';
+
+// Configuration
+const CLAUDE_CLI = process.env.CLAUDE_CLI_PATH || 'claude';
+const DEFAULT_TIMEOUT_MS = 600000; // 10 minutes per turn
+const MAX_TURNS = 100;
+
+// Track running processes for stop functionality (only active processes)
+const runningProcesses = new Map();
+
+/**
+ * Execute a single turn for a task
+ * Stateless - queries timeline to determine what to do
+ *
+ * @param {Object} options
+ * @param {string} options.task_id - Task ID
+ * @param {string} options.session_id - Teleportation session ID
+ * @param {Object} options.config - Config with relayApiUrl, apiKey
+ * @returns {Promise<Object>} Execution result
+ */
+export async function executeTaskTurn(options) {
+  const { task_id, session_id, config } = options;
+  const { relayApiUrl, apiKey } = config;
+
+  // 1. Fetch task from Redis
+  const task = await fetchTask(task_id, session_id, config);
+  if (!task) {
+    return { success: false, error: 'Task not found' };
+  }
+
+  // 2. Fetch timeline for parent session
+  const timeline = await fetchTimeline(session_id, config);
+
+  // 3. Analyze timeline to determine current state
+  const state = analyzeTaskState(timeline, task_id);
+
+  console.log(`[task-v2] Task ${task_id.slice(0, 20)}... state: ${state.state}, turn: ${state.turn_count}`);
+
+  // 4. Check if should stop
+  const stopCheck = shouldStopTask(state, MAX_TURNS);
+  if (stopCheck) {
+    console.log(`[task-v2] Task should stop: ${stopCheck.reason}`);
+    await updateTaskStatus(task_id, session_id, 'stopped', config);
+    return { success: true, stopped: true, reason: stopCheck.reason };
+  }
+
+  // 5. Check if ready for execution
+  if (!state.ready_for_execution) {
+    console.log(`[task-v2] Task not ready: ${state.reason || state.state}`);
+    return { success: true, waiting: true, reason: state.reason || state.state };
+  }
+
+  // 6. Determine prompt
+  const prompt = getNextPrompt(state, task);
+  if (!prompt) {
+    return { success: false, error: 'No prompt available' };
+  }
+
+  // 7. Determine which session to resume
+  // First turn: resume parent session for context
+  // Subsequent turns: resume child session from previous turn
+  const resumeSessionId = state.claude_session_id || task.parent_claude_session_id;
+
+  if (!resumeSessionId) {
+    console.error(`[task-v2] No session ID to resume for task ${task_id}`);
+    return { success: false, error: 'No session ID to resume' };
+  }
+
+  console.log(`[task-v2] Executing turn ${state.turn_count + 1} for task ${task_id.slice(0, 20)}...`);
+  console.log(`[task-v2] Resuming session: ${resumeSessionId}`);
+  console.log(`[task-v2] Prompt: ${prompt.slice(0, 100)}...`);
+
+  // 8. Execute Claude headless
+  try {
+    const result = await executeClaudeHeadless({
+      prompt,
+      cwd: task.cwd || process.cwd(),
+      resumeSessionId,
+      budgetUsd: task.budget_usd - task.cost_usd,
+      taskId: task_id,
+      parentSessionId: task.session_id,
+    });
+
+    // 9. Ingest transcript to timeline
+    // This ensures all events (especially assistant responses) are captured
+    // even if hooks failed to log them during execution
+    if (result.session_id) {
+      try {
+        await ingestTranscriptToTimeline({
+          claude_session_id: result.session_id,
+          parent_session_id: session_id,
+          task_id: task_id,
+          cwd: task.cwd || process.cwd(), // Pass cwd for project slug derivation
+          config,
+        });
+      } catch (error) {
+        // Don't fail the whole turn if transcript ingestion fails
+        console.error(`[task-v2] Failed to ingest transcript:`, error.message);
+      }
+    }
+
+    // 10. Update task in Redis with results
+    await updateTaskAfterTurn(task_id, session_id, result, task, config);
+
+    return {
+      success: true,
+      executed: true,
+      turn_count: state.turn_count + 1,
+      cost_usd: result.cost_usd,
+      claude_session_id: result.session_id,
+    };
+  } catch (error) {
+    console.error(`[task-v2] Execution error:`, error);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Fetch task from relay API
+ */
+async function fetchTask(task_id, session_id, config) {
+  const { relayApiUrl, apiKey } = config;
+
+  const response = await fetch(
+    `${relayApiUrl}/api/sessions/${session_id}/tasks/${task_id}/status`,
+    {
+      headers: { 'Authorization': `Bearer ${apiKey}` }
+    }
+  );
+
+  if (!response.ok) {
+    if (response.status === 404) {
+      return null;
+    }
+    throw new Error(`Failed to fetch task: ${response.status}`);
+  }
+
+  return await response.json();
+}
+
+/**
+ * Update task status in Redis via relay API
+ */
+async function updateTaskStatus(task_id, session_id, status, config) {
+  const { relayApiUrl, apiKey } = config;
+
+  const response = await fetch(
+    `${relayApiUrl}/api/sessions/${session_id}/tasks/${task_id}`,
+    {
+      method: 'PATCH',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ status })
+    }
+  );
+
+  if (!response.ok) {
+    throw new Error(`Failed to update task status: ${response.status}`);
+  }
+
+  return await response.json();
+}
+
+/**
+ * Update task after turn execution
+ */
+async function updateTaskAfterTurn(task_id, session_id, result, currentTask, config) {
+  const { relayApiUrl, apiKey } = config;
+
+  // Accumulate cost
+  const totalCost = (currentTask.cost_usd || 0) + (result.cost_usd || 0);
+
+  const updates = {
+    claude_session_id: result.session_id || currentTask.claude_session_id,
+    cost_usd: totalCost,
+    turn_count: (currentTask.turn_count || 0) + 1,
+  };
+
+  const response = await fetch(
+    `${relayApiUrl}/api/sessions/${session_id}/tasks/${task_id}`,
+    {
+      method: 'PATCH',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(updates)
+    }
+  );
+
+  if (!response.ok) {
+    throw new Error(`Failed to update task: ${response.status}`);
+  }
+
+  return await response.json();
+}
+
+/**
+ * Execute Claude Code in headless mode
+ * (Same as original implementation)
+ */
+async function executeClaudeHeadless(options) {
+  const {
+    prompt,
+    cwd,
+    resumeSessionId,
+    budgetUsd,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    taskId,
+    parentSessionId,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = [];
+
+    // Resume existing session
+    if (resumeSessionId) {
+      args.push('--resume', resumeSessionId);
+    }
+
+    // Add prompt
+    args.push('-p', prompt);
+
+    // Output format for structured parsing
+    args.push('--output-format', 'stream-json');
+    args.push('--verbose');
+
+    // Budget control
+    if (budgetUsd > 0) {
+      args.push('--max-budget-usd', budgetUsd.toFixed(2));
+    }
+
+    console.log(`[task-v2] Executing: ${CLAUDE_CLI} ${args.join(' ')}`);
+
+    const proc = spawn(CLAUDE_CLI, args, {
+      cwd,
+      stdio: 'pipe',
+      env: {
+        ...process.env,
+        CI: 'true',
+        TELEPORTATION_TASK_MODE: 'true',
+        // Route approvals to parent session timeline
+        ...(parentSessionId && { TELEPORTATION_PARENT_SESSION_ID: parentSessionId }),
+      },
+    });
+
+    // Track process for stop functionality
+    if (taskId) {
+      runningProcesses.set(taskId, proc);
+    }
+
+    // Close stdin
+    proc.stdin.end();
+
+    let stdout = '';
+    let stderr = '';
+    let buffer = '';
+
+    const result = {
+      success: false,
+      output: '',
+      error: null,
+      exit_code: 0,
+      session_id: null,
+      cost_usd: 0,
+      usage: {
+        input_tokens: 0,
+        output_tokens: 0,
+      },
+    };
+
+    // Timeout handler
+    const timeout = setTimeout(() => {
+      proc.kill('SIGTERM');
+      setTimeout(() => proc.kill('SIGKILL'), 2000);
+    }, timeoutMs);
+
+    proc.stdout.on('data', (data) => {
+      const chunk = data.toString();
+      stdout += chunk;
+      buffer += chunk;
+
+      // Process stream-json lines
+      const lines = buffer.split('\n');
+      buffer = lines.pop();
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const event = JSON.parse(line);
+
+          // Extract session_id
+          if (event.session_id) {
+            result.session_id = event.session_id;
+          }
+
+          // Extract cost and usage
+          if (event.usage) {
+            result.cost_usd = event.usage.total_cost || 0;
+            result.usage = event.usage;
+          }
+        } catch (e) {
+          // Not JSON, skip
+        }
+      }
+    });
+
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      clearTimeout(timeout);
+
+      if (taskId) {
+        runningProcesses.delete(taskId);
+      }
+
+      result.exit_code = code;
+      result.output = stdout;
+      result.error = stderr;
+      result.success = code === 0;
+
+      resolve(result);
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(timeout);
+
+      if (taskId) {
+        runningProcesses.delete(taskId);
+      }
+
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Stop a running task
+ */
+export function stopTask(task_id) {
+  const proc = runningProcesses.get(task_id);
+  if (proc) {
+    proc.kill('SIGTERM');
+    setTimeout(() => {
+      if (runningProcesses.has(task_id)) {
+        proc.kill('SIGKILL');
+      }
+    }, 2000);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Stop all running tasks
+ * Used during daemon shutdown to ensure clean exit
+ */
+export function stopAllTasks() {
+  console.log(`[task-v2] Stopping all tasks (${runningProcesses.size} processes active)`);
+
+  for (const [task_id, proc] of runningProcesses) {
+    try {
+      let killTimer = null;
+
+      // Setup exit handler to clear timer
+      proc.once('exit', () => {
+        if (killTimer) {
+          clearTimeout(killTimer);
+          killTimer = null;
+        }
+      });
+
+      // Try graceful SIGTERM
+      proc.kill('SIGTERM');
+
+      // Setup watchdog timer for SIGKILL if needed
+      killTimer = setTimeout(() => {
+        try {
+          if (runningProcesses.has(task_id)) {
+            proc.kill('SIGKILL');
+            console.log(`[task-v2] Force killed task ${task_id} (SIGTERM timeout)`);
+          }
+        } catch (killError) {
+          // Process might already be dead
+        }
+      }, 2000);
+
+      runningProcesses.delete(task_id);
+    } catch (error) {
+      console.error(`[task-v2] Error stopping task ${task_id}:`, error.message);
+    }
+  }
+}
+
+export { runningProcesses };