teleportation-cli 1.2.2 → 1.4.0

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

@@ -22,6 +22,37 @@ const MAX_TURNS = 100;
 // Track running processes for stop functionality (only active processes)
 const runningProcesses = new Map();
 
+/**
+ * Extract Claude's text response from stream-json output
+ * Stream-json format: one JSON object per line, assistant text is in
+ * {"type":"assistant","message":{"content":[{"type":"text","text":"..."}]}}
+ * @param {string} output - Raw stream-json stdout
+ * @returns {string} Extracted text or empty string
+ */
+function extractAssistantText(output) {
+  if (!output) return '';
+  const lines = output.split('\n');
+  // Search from end — the last assistant message is most relevant for display
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!line.trim()) continue;
+    try {
+      const event = JSON.parse(line);
+      if (event.type === 'assistant' && event.message?.content) {
+        const textBlock = Array.isArray(event.message.content)
+          ? event.message.content.find(c => c.type === 'text')
+          : null;
+        if (textBlock?.text) {
+          return textBlock.text.trim().substring(0, 2000);
+        }
+      }
+    } catch {
+      // Not JSON, skip
+    }
+  }
+  return '';
+}
+
 /**
  * Execute a single turn for a task
  * Stateless - queries timeline to determine what to do
@@ -71,42 +102,58 @@ export async function executeTaskTurn(options) {
   }
 
   // 7. Determine which session to resume
-  // First turn: resume parent session for context
+  // First turn: start fresh (don't resume parent — it's actively in use)
   // 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' };
-  }
+  const resumeSessionId = state.claude_session_id || null;
 
   console.log(`[task-v2] Executing turn ${state.turn_count + 1} for task ${task_id.slice(0, 20)}...`);
-  console.log(`[task-v2] Resuming session: ${resumeSessionId}`);
+  if (resumeSessionId) {
+    console.log(`[task-v2] Resuming child session: ${resumeSessionId}`);
+  } else {
+    console.log(`[task-v2] Starting fresh session (first turn)`);
+  }
   console.log(`[task-v2] Prompt: ${prompt.slice(0, 100)}...`);
 
+  // 7.5 Check remaining budget before executing
+  const remainingBudget = (task.budget_usd || 0) - (task.cost_usd || 0);
+  if (remainingBudget <= 0) {
+    console.log(`[task-v2] Budget exhausted: $${task.cost_usd} of $${task.budget_usd} used`);
+    await updateTaskStatus(task_id, session_id, 'stopped', config);
+    return { success: true, stopped: true, reason: 'Budget exhausted' };
+  }
+
   // 8. Execute Claude headless
   try {
     const result = await executeClaudeHeadless({
       prompt,
       cwd: task.cwd || process.cwd(),
       resumeSessionId,
-      budgetUsd: task.budget_usd - task.cost_usd,
+      budgetUsd: remainingBudget,
       taskId: task_id,
       parentSessionId: task.session_id,
+      bypassPermissions: task.bypass_permissions,
     });
 
     // 9. Ingest transcript to timeline
     // This ensures all events (especially assistant responses) are captured
     // even if hooks failed to log them during execution
+    let transcriptIngested = false;
     if (result.session_id) {
       try {
-        await ingestTranscriptToTimeline({
+        const ingestionResult = 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,
         });
+        // Only consider ingested if events were actually pushed to timeline
+        // When transcript isn't found (child session in different project dir),
+        // events_pushed will be 0 and we must fall back to manual POST
+        transcriptIngested = (ingestionResult?.events_pushed || 0) > 0;
+        if (!transcriptIngested) {
+          console.log(`[task-v2] Transcript ingestion returned 0 events — will use fallback POST`);
+        }
       } catch (error) {
         // Don't fail the whole turn if transcript ingestion fails
         console.error(`[task-v2] Failed to ingest transcript:`, error.message);
@@ -116,6 +163,65 @@ export async function executeTaskTurn(options) {
     // 10. Update task in Redis with results
     await updateTaskAfterTurn(task_id, session_id, result, task, config);
 
+    // 11. Log task turn completion to timeline so analyzeTaskState() can track progress
+    // Only emit this fallback marker if transcript ingestion didn't already emit events.
+    // Both paths produce assistant_response events with task_id, so emitting both
+    // would double-count turns in analyzeTaskState().
+    if (!transcriptIngested) {
+      try {
+        const resp = await fetch(`${relayApiUrl}/api/timeline`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            session_id,
+            type: 'assistant_response',
+            data: {
+              task_id,
+              source: 'cli_interactive',
+              claude_session_id: result.session_id,
+              turn: state.turn_count + 1,
+              cost_usd: result.cost_usd,
+              timestamp: Date.now(),
+              message: extractAssistantText(result.output) || 'Turn completed',
+            }
+          })
+        });
+        if (!resp.ok) {
+          console.error(`[task-v2] Turn completion POST failed: ${resp.status}`);
+        } else {
+          console.log(`[task-v2] Logged turn ${state.turn_count + 1} completion to timeline (fallback)`);
+        }
+      } catch (e) {
+        console.error(`[task-v2] Failed to log turn completion:`, e.message);
+      }
+    } else {
+      console.log(`[task-v2] Turn ${state.turn_count + 1} events already ingested via transcript`);
+    }
+
+    // 12. Auto-pause: unless auto_continue is set, pause after each turn
+    // This is the default behavior — user must send a message to continue
+    // CRITICAL: If this fails, the task stays 'running' and re-executes on the next
+    // poll cycle, causing the same infinite loop this PR fixes. Retry once on failure.
+    if (!task.auto_continue) {
+      console.log(`[task-v2] Pausing task after turn ${state.turn_count + 1} (auto_continue not set)`);
+      try {
+        await updateTaskStatus(task_id, session_id, 'paused', config);
+      } catch (pauseError) {
+        console.error(`[task-v2] Failed to pause task (retrying once): ${pauseError.message}`);
+        try {
+          await new Promise(r => setTimeout(r, 1000));
+          await updateTaskStatus(task_id, session_id, 'paused', config);
+        } catch (retryError) {
+          console.error(`[task-v2] CRITICAL: Failed to pause task after retry: ${retryError.message}`);
+          // Return error so daemon doesn't re-execute this turn
+          return { success: false, error: 'Failed to pause task — cannot guarantee no re-execution' };
+        }
+      }
+    }
+
     return {
       success: true,
       executed: true,
@@ -187,11 +293,19 @@ async function updateTaskAfterTurn(task_id, session_id, result, currentTask, con
   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,
+    // Clear consumed prompts to prevent re-use on next turn
+    pending_answer: null,
+    pending_redirect: null,
   };
 
+  // Only include claude_session_id if we have a valid one (relay rejects null)
+  const sessionId = result.session_id || currentTask.claude_session_id;
+  if (sessionId) {
+    updates.claude_session_id = sessionId;
+  }
+
   const response = await fetch(
     `${relayApiUrl}/api/sessions/${session_id}/tasks/${task_id}`,
     {
@@ -205,7 +319,8 @@ async function updateTaskAfterTurn(task_id, session_id, result, currentTask, con
   );
 
   if (!response.ok) {
-    throw new Error(`Failed to update task: ${response.status}`);
+    const body = await response.text().catch(() => '');
+    throw new Error(`Failed to update task: ${response.status} ${body}`);
   }
 
   return await response.json();
@@ -241,6 +356,13 @@ async function executeClaudeHeadless(options) {
     args.push('--output-format', 'stream-json');
     args.push('--verbose');
 
+    // Permission mode: configurable per-task or via config
+    // Default: no override (uses hooks → approvals show on mobile UI)
+    // User can set bypass to skip approvals for trusted tasks
+    if (options.bypassPermissions) {
+      args.push('--permission-mode', 'bypassPermissions');
+    }
+
     // Budget control
     if (budgetUsd > 0) {
       args.push('--max-budget-usd', budgetUsd.toFixed(2));
@@ -248,21 +370,25 @@ async function executeClaudeHeadless(options) {
 
     console.log(`[task-v2] Executing: ${CLAUDE_CLI} ${args.join(' ')}`);
 
+    // Build child env: unset CLAUDECODE to allow nested Claude launches
+    const childEnv = {
+      ...process.env,
+      CI: 'true',
+      TELEPORTATION_TASK_MODE: 'true',
+      // Route approvals to parent session timeline
+      ...(parentSessionId && { TELEPORTATION_PARENT_SESSION_ID: parentSessionId }),
+    };
+    delete childEnv.CLAUDECODE;
+
     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 }),
-      },
+      env: childEnv,
     });
 
-    // Track process for stop functionality
+    // Track process for stop functionality (includes session_id for per-session filtering)
     if (taskId) {
-      runningProcesses.set(taskId, proc);
+      runningProcesses.set(taskId, { proc, session_id: parentSessionId });
     }
 
     // Close stdin
@@ -279,6 +405,7 @@ async function executeClaudeHeadless(options) {
       exit_code: 0,
       session_id: null,
       cost_usd: 0,
+      _costExplicitlySet: false, // Track if total_cost_usd was found
       usage: {
         input_tokens: 0,
         output_tokens: 0,
@@ -311,8 +438,18 @@ async function executeClaudeHeadless(options) {
           }
 
           // Extract cost and usage
+          // stream-json 'result' event has total_cost_usd at top level
+          // e.g. {"type":"result","total_cost_usd":0.72,"usage":{...}}
+          if (event.total_cost_usd != null) {
+            result.cost_usd = event.total_cost_usd;
+            result._costExplicitlySet = true;
+          }
           if (event.usage) {
-            result.cost_usd = event.usage.total_cost || 0;
+            // Fallback: older format had usage.total_cost
+            // Only use fallback if total_cost_usd was never found (not just zero)
+            if (!result._costExplicitlySet && event.usage.total_cost) {
+              result.cost_usd = event.usage.total_cost;
+            }
             result.usage = event.usage;
           }
         } catch (e) {
@@ -337,6 +474,10 @@ async function executeClaudeHeadless(options) {
       result.error = stderr;
       result.success = code === 0;
 
+      if (!result._costExplicitlySet && result.cost_usd === 0 && code === 0) {
+        console.warn(`[task-v2] No cost data found in stream-json output`);
+      }
+
       resolve(result);
     });
 
@@ -356,19 +497,57 @@ async function executeClaudeHeadless(options) {
  * Stop a running task
  */
 export function stopTask(task_id) {
-  const proc = runningProcesses.get(task_id);
-  if (proc) {
+  const entry = runningProcesses.get(task_id);
+  if (entry) {
+    // All entries are {proc, session_id} objects (set in executeClaudeHeadless)
+    const proc = entry.proc;
+    // If process already exited, no need to kill or set timer
+    if (proc.exitCode !== null) {
+      runningProcesses.delete(task_id);
+      return true;
+    }
     proc.kill('SIGTERM');
-    setTimeout(() => {
+    const killTimer = setTimeout(() => {
       if (runningProcesses.has(task_id)) {
-        proc.kill('SIGKILL');
+        try { proc.kill('SIGKILL'); } catch {}
       }
     }, 2000);
+    proc.once('exit', () => clearTimeout(killTimer));
     return true;
   }
   return false;
 }
 
+/**
+ * Stop all running tasks for a specific session
+ * Returns number of processes killed
+ */
+export function stopTasksForSession(session_id) {
+  let killed = 0;
+  for (const [task_id, entry] of runningProcesses) {
+    if (entry.session_id !== session_id) continue;
+    const proc = entry.proc;
+    if (proc.exitCode !== null) {
+      runningProcesses.delete(task_id);
+      continue;
+    }
+    try {
+      proc.kill('SIGTERM');
+      const killTimer = setTimeout(() => {
+        try { proc.kill('SIGKILL'); } catch {}
+      }, 2000);
+      proc.once('exit', () => {
+        clearTimeout(killTimer);
+        runningProcesses.delete(task_id);
+      });
+      killed++;
+    } catch (err) {
+      // Process may already be dead
+    }
+  }
+  return killed;
+}
+
 /**
  * Stop all running tasks
  * Used during daemon shutdown to ensure clean exit
@@ -376,8 +555,10 @@ export function stopTask(task_id) {
 export function stopAllTasks() {
   console.log(`[task-v2] Stopping all tasks (${runningProcesses.size} processes active)`);
 
-  for (const [task_id, proc] of runningProcesses) {
+  for (const [task_id, entry] of runningProcesses) {
     try {
+      // All entries are {proc, session_id} objects (set in executeClaudeHeadless)
+      const proc = entry.proc;
       let killTimer = null;
 
       // Setup exit handler to clear timer