teleportation-cli 1.1.5 → 1.2.0

package/lib/daemon/task-executor.js

@@ -13,7 +13,7 @@
  * - 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`
+ * - Hooks fire normally (approvals go to mobile app)
  *
  * @module lib/daemon/task-executor
  */
@@ -74,6 +74,7 @@ export function removeTaskLock(taskId) {
  * @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 {boolean} auto_continue - Whether to automatically continue after each turn
  * @property {number} budget_usd - Total budget allocated
  * @property {number} cost_usd - Total cost incurred so far
  * @property {number} started_at - Timestamp when task started
@@ -226,6 +227,7 @@ function generateTaskId() {
  * @param {number} options.budgetUsd - Max budget in USD
  * @param {number} options.timeoutMs - Timeout in milliseconds
  * @param {string} options.taskId - Task session ID for tracking
+ * @param {Function} [options.onUpdate] - Optional callback for streaming updates
  * @returns {Promise<Object>} Execution result with session_id, output, cost, etc.
  */
 async function executeClaudeHeadless(options) {
@@ -236,6 +238,8 @@ async function executeClaudeHeadless(options) {
     budgetUsd,
     timeoutMs = DEFAULT_TIMEOUT_MS,
     taskId,
+    parentSessionId,
+    onUpdate,
   } = options;
 
   return new Promise((resolve, reject) => {
@@ -249,16 +253,18 @@ async function executeClaudeHeadless(options) {
     // Add prompt
     args.push('-p', prompt);
 
-    // Output format for structured parsing
-    args.push('--output-format', 'json');
+    // Output format for structured parsing - using stream-json for real-time metadata
+    args.push('--output-format', 'stream-json');
+    args.push('--verbose');
 
     // 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');
+    // Hooks enabled: approvals route to mobile app
+    // Session must be in "away" mode for hooks to wait for remote approval
+    // (Daemon sets away mode before calling startTask)
 
     console.log(`[task] Executing: ${CLAUDE_CLI} ${args.join(' ')}`);
 
@@ -269,6 +275,8 @@ async function executeClaudeHeadless(options) {
         ...process.env,
         CI: 'true', // Non-interactive mode
         TELEPORTATION_TASK_MODE: 'true',
+        // Pass parent session ID so hooks can log approvals to correct timeline
+        ...(parentSessionId && { TELEPORTATION_PARENT_SESSION_ID: parentSessionId }),
       },
     });
 
@@ -281,6 +289,27 @@ async function executeClaudeHeadless(options) {
     let stdout = '';
     let stderr = '';
     let timedOut = false;
+    let buffer = '';
+
+    // Final result structure
+    let result = {
+      success: false,
+      output: '',
+      error: null,
+      exit_code: 0,
+      session_id: null,
+      cost_usd: 0,
+      duration_ms: 0,
+      model: null,
+      usage: {
+        tools_used: 0,
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0
+      },
+      tool_calls: [],
+    };
 
     // Timeout handler
     const timeout = setTimeout(() => {
@@ -289,7 +318,56 @@ async function executeClaudeHeadless(options) {
     }, timeoutMs);
 
     proc.stdout.on('data', (data) => {
-      stdout += data.toString();
+      const chunk = data.toString();
+      stdout += chunk;
+      buffer += chunk;
+
+      // Process stream-json lines
+      const lines = buffer.split('\n');
+      buffer = lines.pop(); // Keep last incomplete line
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          // Debug: console.debug(`[stream] Line: ${line.slice(0, 100)}`);
+          const msg = JSON.parse(line);
+          
+          // Accumulate metadata from stream
+          if (msg.type === 'system' && msg.subtype === 'init' && msg.session_id) {
+            result.session_id = msg.session_id;
+          }
+
+          if (msg.type === 'assistant' && msg.message?.content) {
+            const content = msg.message.content;
+            for (const block of content) {
+              if (block.type === 'text') {
+                result.output += block.text;
+                if (onUpdate) onUpdate({ type: 'text', text: block.text });
+              } else if (block.type === 'tool_use') {
+                result.usage.tools_used++;
+                result.tool_calls.push(block);
+                if (onUpdate) onUpdate({ type: 'tool_use', tool: block.name });
+              }
+            }
+          }
+
+          if (msg.type === 'usage' || (msg.type === 'assistant' && msg.message?.usage)) {
+            const usage = msg.usage || msg.message.usage;
+            result.usage.input_tokens += usage.input_tokens || 0;
+            result.usage.output_tokens += usage.output_tokens || 0;
+            result.usage.cache_creation_input_tokens += usage.cache_creation_input_tokens || 0;
+            result.usage.cache_read_input_tokens += usage.cache_read_input_tokens || 0;
+          }
+
+          if (msg.type === 'result') {
+             result.success = !msg.is_error;
+             if (msg.is_error) result.error = msg.error;
+             if (msg.total_cost_usd) result.cost_usd = msg.total_cost_usd;
+          }
+        } catch (e) {
+          // Non-JSON line, ignore or log
+        }
+      }
     });
 
     proc.stderr.on('data', (data) => {
@@ -300,54 +378,30 @@ async function executeClaudeHeadless(options) {
       clearTimeout(timeout);
       runningProcesses.delete(taskId);
 
+      result.exit_code = code;
+      result.duration_ms = Date.now() - (result.start_time || Date.now());
+
       if (timedOut) {
-        resolve({
-          success: false,
-          output: stdout,
-          error: 'Execution timed out',
-          exit_code: -1,
-          session_id: null,
-          cost_usd: 0,
-          duration_ms: timeoutMs,
-        });
-        return;
+        result.success = false;
+        result.error = 'Execution timed out';
+        result.exit_code = -1;
+      } else if (code !== 0 && !result.error) {
+        result.success = false;
+        result.error = stderr || `Exit code: ${code}`;
+      } else if (code === 0) {
+        result.success = true;
       }
 
-      // 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];
+      // If output is still empty but we have stdout that wasn't stream-json, 
+      // fall back to raw stdout
+      if (!result.output && stdout) {
+        try {
+          const parsed = JSON.parse(stdout);
+          result.output = parsed.result || parsed.response || parsed.output || stdout;
+          result.session_id = result.session_id || parsed.session_id;
+          result.cost_usd = result.cost_usd || parsed.cost || 0;
+        } catch {
+          result.output = stdout;
         }
       }
 
@@ -370,6 +424,7 @@ async function executeClaudeHeadless(options) {
  * @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 {boolean} [options.auto_continue=false] - Auto-continue after each turn (default: false). When disabled, task pauses after each turn and waits for user message.
  * @param {Function} [options.onEvent] - Callback for task events
  * @returns {Promise<TaskSession>}
  */
@@ -379,9 +434,14 @@ export async function startTask(options) {
     session_id,
     cwd,
     budget_usd = DEFAULT_BUDGET_USD,
+    parent_claude_session_id = null,
+    auto_continue: rawAutoContinue = false,
     onEvent,
   } = options;
 
+  // Validate auto_continue parameter - ensure it's a boolean
+  const auto_continue = Boolean(rawAutoContinue ?? false);
+
   const taskId = options.task_id || generateTaskId(); 
   const now = Date.now();
   const lockPath = path.join(TASKS_LOCK_DIR, `${taskId}.pid`);
@@ -456,7 +516,9 @@ export async function startTask(options) {
     teleportation_session_id: session_id,
     task,
     status: 'running',
-    claude_session_id: null,
+    claude_session_id: null, // Will be set to child session on first execution
+    parent_claude_session_id, // Parent session to resume for context
+    auto_continue, // Whether to automatically continue or wait for user messages
     budget_usd,
     cost_usd: 0,
     started_at: now,
@@ -474,6 +536,7 @@ export async function startTask(options) {
   if (onEvent) {
     onEvent({
       type: 'task_started',
+      source: 'autonomous_task',
       task_id: taskId,
       session_id,
       task,
@@ -501,6 +564,7 @@ export async function startTask(options) {
       if (onEvent) {
         onEvent({
           type: 'task_stopped',
+          source: 'autonomous_task',
           task_id: taskId,
           reason: `Error: ${err.message}`,
           timestamp: Date.now(),
@@ -543,6 +607,7 @@ async function executeTaskLoop(taskId, onEvent) {
       if (onEvent) {
         onEvent({
           type: 'task_stopped',
+          source: 'autonomous_task',
           task_id: taskId,
           reason: `Max turns limit reached (${MAX_TURNS})`,
           cost_usd: session.cost_usd,
@@ -564,6 +629,7 @@ async function executeTaskLoop(taskId, onEvent) {
         if (onEvent) {
           onEvent({
             type: 'task_stopped',
+            source: 'autonomous_task',
             task_id: taskId,
             reason: 'Pause timeout - no resume received',
             timestamp: Date.now(),
@@ -583,6 +649,7 @@ async function executeTaskLoop(taskId, onEvent) {
       if (onEvent) {
         onEvent({
           type: 'task_budget_hit',
+          source: 'autonomous_task',
           task_id: taskId,
           cost_usd: session.cost_usd,
           budget_usd: session.budget_usd,
@@ -593,9 +660,55 @@ async function executeTaskLoop(taskId, onEvent) {
     }
 
     // Build prompt for this turn
-    const prompt = session.turn_count === 0
-      ? session.task
-      : 'Continue working on the task.';
+    let prompt;
+    if (session.turn_count === 0) {
+      // First turn: use the original task description
+      prompt = session.task;
+    } else if (session.auto_continue) {
+      // Auto-continuation enabled: use generic continuation
+      prompt = 'Continue working on the task.';
+    } else {
+      // Auto-continuation disabled: pause and wait for user message
+      session.status = 'paused';
+      session.updated_at = Date.now();
+      console.log(`[task] Turn ${session.turn_count + 1}: Auto-continue disabled, pausing for user input`);
+      if (onEvent) {
+        onEvent({
+          type: 'task_paused',
+          source: 'autonomous_task',
+          task_id: taskId,
+          reason: 'Waiting for user message (auto_continue disabled)',
+          turn_count: session.turn_count,
+          timestamp: Date.now(),
+        });
+      }
+      // Wait for resume with user message
+      try {
+        await waitForResume(taskId);
+        // Atomically get and clear pending_question to prevent race conditions
+        const userMessage = atomicGetAndClearMessage(taskId);
+        if (!userMessage) {
+          console.log(`[task] Resumed without user message, stopping task ${taskId}`);
+          session.status = 'stopped';
+          session.updated_at = Date.now();
+          break;
+        }
+        // Use the user's message as the prompt
+        prompt = userMessage;
+      } catch (timeoutError) {
+        console.log(`[task] Session ${taskId} pause timeout: ${timeoutError.message}`);
+        if (onEvent) {
+          onEvent({
+            type: 'task_stopped',
+            source: 'autonomous_task',
+            task_id: taskId,
+            reason: 'Pause timeout - no user message received',
+            timestamp: Date.now(),
+          });
+        }
+        break;
+      }
+    }
 
     // Execute Claude
     session.turn_count++;
@@ -609,12 +722,37 @@ async function executeTaskLoop(taskId, onEvent) {
     }
 
     try {
+      // Determine which session to resume:
+      // - Turn 1: Resume parent session for context (if available)
+      // - Turn 2+: Resume child session from previous turn
+      const resumeSessionId = session.claude_session_id
+        ? session.claude_session_id  // Use child session from previous turns
+        : session.parent_claude_session_id;  // Use parent session on first turn
+
+      if (resumeSessionId && session.turn_count === 1) {
+        console.log(`[task] Turn 1: Resuming parent session ${resumeSessionId} for context`);
+      } else if (resumeSessionId) {
+        console.log(`[task] Turn ${session.turn_count}: Resuming child session ${resumeSessionId}`);
+      }
+
       const result = await executeClaudeHeadless({
         prompt,
         cwd: session.cwd,
-        resumeSessionId: session.claude_session_id,
+        resumeSessionId,
         budgetUsd: remainingBudget,
         taskId,
+        parentSessionId: session.teleportation_session_id,
+        onUpdate: (update) => {
+          if (onEvent) {
+            onEvent({
+              type: 'task_progress',
+              source: 'autonomous_task',
+              task_id: taskId,
+              update,
+              timestamp: Date.now(),
+            });
+          }
+        }
       });
 
       // Update session with result
@@ -629,6 +767,7 @@ async function executeTaskLoop(taskId, onEvent) {
         output: result.output?.slice(0, 2000), // Truncate for storage
         cost_usd: result.cost_usd,
         success: result.success,
+        usage: result.usage,
         timestamp: Date.now(),
       });
 
@@ -649,6 +788,7 @@ async function executeTaskLoop(taskId, onEvent) {
           if (onEvent) {
             onEvent({
               type: 'task_stopped',
+              source: 'autonomous_task',
               task_id: taskId,
               reason: `${MAX_CONSECUTIVE_FAILURES} consecutive failures`,
               cost_usd: session.cost_usd,
@@ -698,6 +838,7 @@ async function executeTaskLoop(taskId, onEvent) {
           if (onEvent) {
             onEvent({
               type: 'task_completed',
+              source: 'autonomous_task',
               task_id: taskId,
               output: result.output,
               cost_usd: session.cost_usd,
@@ -716,6 +857,7 @@ async function executeTaskLoop(taskId, onEvent) {
           if (onEvent) {
             onEvent({
               type: 'task_question',
+              source: 'autonomous_task',
               task_id: taskId,
               question: classification.questionText,
               confidence: classification.confidence,
@@ -742,6 +884,7 @@ async function executeTaskLoop(taskId, onEvent) {
       if (onEvent) {
         onEvent({
           type: 'task_stopped',
+          source: 'autonomous_task',
           task_id: taskId,
           reason: `Error: ${error.message}`,
           timestamp: Date.now(),
@@ -779,7 +922,7 @@ async function waitForResume(taskId, timeoutMs = WAIT_FOR_RESUME_TIMEOUT_MS) {
         if (session) {
           session.status = 'stopped';
           session.updated_at = Date.now();
-          
+
           // Remove lock file on timeout
           removeTaskLock(taskId);
         }
@@ -797,6 +940,23 @@ async function waitForResume(taskId, timeoutMs = WAIT_FOR_RESUME_TIMEOUT_MS) {
   });
 }
 
+/**
+ * Atomically get and clear pending_question from a session
+ * Prevents race conditions where the message could be modified between read and clear
+ * @param {string} taskId
+ * @returns {string|null} The pending question, or null if none exists
+ */
+function atomicGetAndClearMessage(taskId) {
+  const session = taskSessions.get(taskId);
+  if (!session) {
+    return null;
+  }
+
+  const message = session.pending_question;
+  session.pending_question = null;
+  return message;
+}
+
 /**
  * Stop an task task
  *
@@ -941,14 +1101,15 @@ export async function answerTaskQuestion(taskId, answer, onEvent) {
     return { success: false, reason: 'Session not found' };
   }
 
-  if (session.status !== 'waiting_input') {
-    return { success: false, reason: `Cannot answer question in ${session.status} status` };
+  if (session.status !== 'waiting_input' && session.status !== 'paused') {
+    return { success: false, reason: `Cannot send message in ${session.status} status` };
   }
 
   // Emit user input event
   if (onEvent) {
     onEvent({
       type: 'task_user_input',
+      source: 'autonomous_task',
       task_id: taskId,
       question: session.pending_question,
       answer,
@@ -956,49 +1117,62 @@ export async function answerTaskQuestion(taskId, answer, onEvent) {
     });
   }
 
-  // Clear pending question and set status to running
-  session.pending_question = null;
-  session.status = 'running';
-  session.updated_at = Date.now();
+  // Handle based on current status
+  if (session.status === 'paused') {
+    // Task is paused waiting for user message (auto_continue disabled)
+    // Set the message as pending_question and resume the execution loop
+    session.pending_question = answer;
+    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;
+    // The execution loop will pick up the pending_question and use it as the prompt
+    return { success: true };
+  } else {
+    // Task is waiting_input (Claude asked a question)
+    // Execute immediately with the user's answer
+    session.pending_question = null;
+    session.status = 'running';
+    session.updated_at = Date.now();
 
-  try {
-    session.turn_count++;
-    const result = await executeClaudeHeadless({
-      prompt: answer,
-      cwd: session.cwd,
-      resumeSessionId: session.claude_session_id,
-      budgetUsd: remainingBudget,
-      taskId,
-    });
+    const remainingBudget = session.budget_usd - session.cost_usd;
 
-    // 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();
+    try {
+      session.turn_count++;
+      const result = await executeClaudeHeadless({
+        prompt: answer,
+        cwd: session.cwd,
+        resumeSessionId: session.claude_session_id,
+        budgetUsd: remainingBudget,
+        taskId,
+        parentSessionId: session.teleportation_session_id,
+      });
 
-    // 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(),
-    });
+      // 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();
 
-    // Resume the execution loop
-    executeTaskLoop(taskId, onEvent).catch(err => {
-      console.error(`[task] Answer loop error for ${taskId}:`, err.message);
-    });
+      // 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(),
+      });
 
-    return { success: true };
-  } catch (error) {
-    session.status = 'stopped';
-    session.updated_at = Date.now();
-    return { success: false, reason: error.message };
+      // Resume the execution loop
+      executeTaskLoop(taskId, onEvent).catch(err => {
+        console.error(`[task] Answer loop error for ${taskId}:`, err.message);
+      });
+
+      return { success: true };
+    } catch (error) {
+      session.status = 'stopped';
+      session.updated_at = Date.now();
+      return { success: false, reason: error.message };
+    }
   }
 }