@masslessai/push-todo 4.1.7 → 4.1.9

package/lib/api.js

@@ -381,4 +381,144 @@ export async function learnVocabulary(todoId, keywords) {
   return response.json();
 }
 
+// ==================== Phase 3: Extended Skill CLI ====================
+
+/**
+ * Report structured progress for a running task.
+ * Called by the agent during execution to push activity updates to Supabase.
+ *
+ * @param {string} todoId - UUID of the task
+ * @param {Object} options - Progress details
+ * @param {string} options.phase - Current phase (e.g., "testing", "implementing")
+ * @param {string} [options.detail] - Human-readable detail
+ * @returns {Promise<Object>}
+ */
+export async function reportProgress(todoId, { phase, detail }) {
+  const response = await apiRequest('update-task-execution', {
+    method: 'PATCH',
+    body: JSON.stringify({
+      todoId,
+      event: {
+        type: 'progress',
+        timestamp: new Date().toISOString(),
+        summary: detail ? `${phase}: ${detail}` : phase,
+        phase
+      }
+    })
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to report progress: ${text}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Update execution status/phase for a running task.
+ *
+ * @param {string} todoId - UUID of the task
+ * @param {string} status - New phase label (e.g., "implementing", "testing", "reviewing")
+ * @returns {Promise<Object>}
+ */
+export async function updateStatus(todoId, status) {
+  const response = await apiRequest('update-task-execution', {
+    method: 'PATCH',
+    body: JSON.stringify({
+      todoId,
+      event: {
+        type: 'progress',
+        timestamp: new Date().toISOString(),
+        summary: `Phase: ${status}`
+      }
+    })
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to update status: ${text}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Check for messages from the human for a running task.
+ * Returns pending messages or empty array.
+ *
+ * @param {string} todoId - UUID of the task
+ * @returns {Promise<Object[]>} Array of pending messages
+ */
+export async function checkMessages(todoId) {
+  const params = new URLSearchParams({ todo_id: todoId, direction: 'to_agent' });
+  const response = await apiRequest(`task-messages?${params}`, {
+    method: 'GET'
+  });
+
+  if (!response.ok) {
+    // 404 = no task_messages table/function yet — return empty gracefully
+    if (response.status === 404) return [];
+    const text = await response.text();
+    throw new Error(`Failed to check messages: ${text}`);
+  }
+
+  const result = await response.json();
+  return result.messages || [];
+}
+
+/**
+ * Request input from the human for a running task.
+ * Posts a question and polls until the human responds or timeout.
+ *
+ * @param {string} todoId - UUID of the task
+ * @param {string} question - Question to ask the human
+ * @param {number} [timeoutMs=300000] - Timeout in ms (default 5 min)
+ * @returns {Promise<string|null>} Human's response or null if timeout
+ */
+export async function requestInput(todoId, question, timeoutMs = 300000) {
+  // Post the question
+  const postResponse = await apiRequest('task-messages', {
+    method: 'POST',
+    body: JSON.stringify({
+      todo_id: todoId,
+      direction: 'to_human',
+      message: question,
+      type: 'input_request'
+    })
+  });
+
+  if (!postResponse.ok) {
+    // 404 = task-messages endpoint not deployed yet
+    if (postResponse.status === 404) {
+      console.error('Message system not available yet. Use [push-confirm] pattern instead.');
+      return null;
+    }
+    const text = await postResponse.text();
+    throw new Error(`Failed to request input: ${text}`);
+  }
+
+  const { message_id } = await postResponse.json();
+
+  // Poll for response
+  const startTime = Date.now();
+  const pollInterval = 5000; // 5s
+
+  while (Date.now() - startTime < timeoutMs) {
+    await new Promise(resolve => setTimeout(resolve, pollInterval));
+
+    const checkResponse = await apiRequest(`task-messages?message_id=${message_id}&direction=to_agent`, {
+      method: 'GET'
+    });
+
+    if (checkResponse.ok) {
+      const result = await checkResponse.json();
+      const reply = (result.messages || []).find(m => m.in_reply_to === message_id);
+      if (reply) return reply.message;
+    }
+  }
+
+  return null; // Timeout
+}
+
 export { API_BASE };

package/lib/cli.js

@@ -68,6 +68,13 @@ ${bold('OPTIONS:')}
   --view-screenshot <idx>          Open screenshot for viewing (index or filename)
   --learn-vocabulary <uuid>        Contribute vocabulary for a task
   --keywords <terms>               Comma-separated vocabulary terms (with --learn-vocabulary)
+  --report-progress <uuid>         Report progress for a running task
+  --phase <name>                   Phase name (with --report-progress)
+  --detail <text>                  Detail text (with --report-progress)
+  --update-status <uuid>           Update execution phase for a running task
+  --check-messages <uuid>          Check for messages from the human
+  --request-input <uuid>           Request input from the human (blocking)
+  --question <text>                Question to ask (with --request-input)
   --set-batch-size <N>             Set max tasks for batch queue (1-20)
   --daemon-status                  Show daemon status
   --daemon-start                   Start daemon manually
@@ -175,6 +182,14 @@ const options = {
   'create-todo': { type: 'string' },
   'notify': { type: 'string' },
   'queue-execution': { type: 'string' },
+  // Skill CLI options (Phase 3)
+  'report-progress': { type: 'string' },
+  'phase': { type: 'string' },
+  'detail': { type: 'string' },
+  'update-status': { type: 'string' },
+  'check-messages': { type: 'string' },
+  'request-input': { type: 'string' },
+  'question': { type: 'string' },
 };
 
 /**
@@ -512,6 +527,91 @@ export async function run(argv) {
     return;
   }
 
+  // Handle --report-progress (report structured progress for a running task)
+  if (values['report-progress']) {
+    try {
+      const result = await api.reportProgress(values['report-progress'], {
+        phase: values.phase || 'progress',
+        detail: values.detail || undefined,
+      });
+      if (values.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(green('Progress reported.'));
+      }
+    } catch (error) {
+      console.error(red(`Failed to report progress: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Handle --update-status (update execution phase for a running task)
+  if (values['update-status']) {
+    const status = positionals[0] || values.phase;
+    if (!status) {
+      console.error(red('Status required. Usage: --update-status <uuid> <status>'));
+      process.exit(1);
+    }
+    try {
+      const result = await api.updateStatus(values['update-status'], status);
+      if (values.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(green(`Status updated to: ${status}`));
+      }
+    } catch (error) {
+      console.error(red(`Failed to update status: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Handle --check-messages (check for messages from the human)
+  if (values['check-messages']) {
+    try {
+      const messages = await api.checkMessages(values['check-messages']);
+      if (values.json) {
+        console.log(JSON.stringify(messages, null, 2));
+      } else if (messages.length === 0) {
+        console.log(dim('No pending messages.'));
+      } else {
+        for (const msg of messages) {
+          console.log(`[${msg.created_at || 'unknown'}] ${msg.message}`);
+        }
+      }
+    } catch (error) {
+      console.error(red(`Failed to check messages: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Handle --request-input (ask the human a question, poll for response)
+  if (values['request-input']) {
+    const question = values.question || positionals.slice(0).join(' ');
+    if (!question) {
+      console.error(red('--question required with --request-input'));
+      console.error('Usage: --request-input <uuid> --question "What should I do?"');
+      process.exit(1);
+    }
+    try {
+      console.log(dim('Waiting for human response (timeout: 5 min)...'));
+      const reply = await api.requestInput(values['request-input'], question);
+      if (values.json) {
+        console.log(JSON.stringify({ reply }, null, 2));
+      } else if (reply) {
+        console.log(green('Response:'), reply);
+      } else {
+        console.log(dim('No response received (timeout).'));
+      }
+    } catch (error) {
+      console.error(red(`Failed to request input: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
   // Auto-start daemon on every command (self-healing behavior)
   ensureDaemonRunning();
 

package/lib/daemon.js

@@ -1482,11 +1482,38 @@ function maybesSendStreamProgress(displayNumber, activity) {
         filesRead: activity.filesRead.size
       }
     })
+  }).then(async (response) => {
+    // Check for cancellation signal in response
+    const result = await response.json().catch(() => null);
+    if (result?.status === 'cancelling') {
+      handleCancellation(displayNumber, 'stream_progress');
+    }
   }).catch(err => {
     log(`Task #${displayNumber}: stream progress failed (non-fatal): ${err.message}`);
   });
 }
 
+// ==================== Cancellation (Phase 2) ====================
+
+function handleCancellation(displayNumber, source) {
+  const taskInfo = runningTasks.get(displayNumber);
+  if (!taskInfo) return;
+
+  log(`Task #${displayNumber}: cancellation detected via ${source}, sending SIGTERM`);
+
+  try {
+    taskInfo.process.kill('SIGTERM');
+  } catch (err) {
+    log(`Task #${displayNumber}: SIGTERM failed: ${err.message}`);
+  }
+
+  // Mark as cancelled so handleTaskCompletion reports the right reason
+  updateTaskDetail(displayNumber, {
+    phase: 'cancelled',
+    detail: 'Cancelled by user'
+  });
+}
+
 function monitorTaskStdout(displayNumber, proc) {
   if (!proc.stdout) return;
 
@@ -1623,6 +1650,12 @@ async function sendProgressHeartbeats() {
         }
         // No status field — event-only update, won't change execution_status
       })
+    }).then(async (response) => {
+      // Check for cancellation signal in heartbeat response
+      const result = await response.json().catch(() => null);
+      if (result?.status === 'cancelling') {
+        handleCancellation(displayNumber, 'heartbeat');
+      }
     }).catch(err => {
       log(`Task #${displayNumber}: heartbeat failed (non-fatal): ${err.message}`);
     });
@@ -2162,12 +2195,45 @@ async function handleTaskCompletion(displayNumber, exitCode) {
   const summary = info.summary || 'Unknown task';
   const projectPath = taskProjectPaths.get(displayNumber);
 
-  log(`Task #${displayNumber} completed with code ${exitCode} (${duration}s)`);
+  const durationStr = duration < 60 ? `${duration}s` : `${Math.floor(duration / 60)}m ${duration % 60}s`;
+  const wasCancelled = info.phase === 'cancelled';
+  log(`Task #${displayNumber} ${wasCancelled ? 'cancelled' : 'completed'} with code ${exitCode} (${duration}s)`);
+
+  // Handle user cancellation — report as failed with clear reason, skip PR/merge/summary
+  if (wasCancelled) {
+    const cancelMsg = `Cancelled by user after ${durationStr}.`;
+    await updateTaskStatus(displayNumber, 'failed', {
+      error: cancelMsg,
+      sessionId: taskInfo.sessionId
+    }, info.taskId);
+
+    cleanupWorktree(displayNumber, projectPath);
+
+    trackCompleted({
+      displayNumber,
+      summary,
+      completedAt: new Date().toISOString(),
+      duration,
+      status: 'cancelled'
+    });
+
+    // Cleanup internal tracking
+    taskDetails.delete(displayNumber);
+    taskLastOutput.delete(displayNumber);
+    taskStdoutBuffer.delete(displayNumber);
+    taskStderrBuffer.delete(displayNumber);
+    taskProjectPaths.delete(displayNumber);
+    taskLastHeartbeat.delete(displayNumber);
+    taskStreamLineBuffer.delete(displayNumber);
+    taskActivityState.delete(displayNumber);
+    taskLastStreamProgress.delete(displayNumber);
+    updateStatusFile();
+    return;
+  }
 
   // Session ID: prefer pre-assigned ID (reliable), fall back to stdout extraction
   const sessionId = taskInfo.sessionId || extractSessionIdFromStdout(taskInfo.process, taskStdoutBuffer.get(displayNumber) || [], displayNumber);
   const worktreePath = getWorktreePath(displayNumber, projectPath);
-  const durationStr = duration < 60 ? `${duration}s` : `${Math.floor(duration / 60)}m ${duration % 60}s`;
   const machineName = getMachineName() || 'Mac';
 
   if (sessionId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@masslessai/push-todo",
-  "version": "4.1.7",
+  "version": "4.1.9",
   "description": "Voice tasks from Push iOS app for Claude Code",
   "type": "module",
   "bin": {