@masslessai/push-todo 3.9.0 → 3.10.1

package/lib/cli.js

@@ -93,6 +93,14 @@ ${bold('CONNECT OPTIONS:')}
   --store-e2ee-key <key>           Import E2EE encryption key
   --description <text>             Project description (with connect)
 
+${bold('CONFIRM (for daemon skills):')}
+  push-todo confirm --type "social_post" --title "Post tweet" --content "..."
+  --type <type>                    Confirmation category (social_post, email, etc.)
+  --title <text>                   Short description of the action
+  --content <text>                 Content to be confirmed
+  --metadata <json>                Optional JSON metadata for rich rendering
+  --task <number>                  Display number (auto-detected in daemon)
+
 ${bold('SETTINGS:')}
   push-todo setting                Show all settings
   push-todo setting auto-commit    Toggle auto-commit
@@ -135,7 +143,13 @@ const options = {
   'validate-key': { type: 'boolean' },
   'validate-project': { type: 'boolean' },
   'store-e2ee-key': { type: 'string' },
-  'description': { type: 'string' }
+  'description': { type: 'string' },
+  // Confirm command options
+  'type': { type: 'string' },
+  'title': { type: 'string' },
+  'content': { type: 'string' },
+  'metadata': { type: 'string' },
+  'task': { type: 'string' },
 };
 
 /**
@@ -465,6 +479,12 @@ export async function run(argv) {
   // Get the command (first positional)
   const command = positionals[0];
 
+  // Confirm command - request user confirmation for irreversible actions
+  if (command === 'confirm') {
+    const { requestConfirmation } = await import('./confirm.js');
+    return requestConfirmation(values, positionals);
+  }
+
   // Connect command
   if (command === 'connect') {
     return runConnect(values);

package/lib/confirm.js

@@ -0,0 +1,226 @@
+/**
+ * Remote confirmation command for Push CLI.
+ *
+ * Requests user confirmation before irreversible external actions.
+ * Claude calls `push-todo confirm --type X --title Y --content Z`
+ * which blocks until the user approves or rejects from the iOS app.
+ *
+ * See: docs/20260212_remote_confirmation_protocol_architecture.md
+ */
+
+import { getApiKey } from './config.js';
+import { getMachineName } from './machine-id.js';
+import { bold, red, cyan, dim, green, yellow } from './utils/colors.js';
+
+const API_BASE = 'https://jxuzqcbqhiaxmfitzxlo.supabase.co/functions/v1';
+
+const POLL_INTERVAL_MS = 3000;
+
+/**
+ * Make an authenticated API request to the Push backend.
+ */
+async function apiRequest(endpoint, options = {}) {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error('No API key configured. Run "push-todo connect" first.');
+  }
+
+  const url = `${API_BASE}/${endpoint}`;
+  return fetch(url, {
+    ...options,
+    headers: {
+      'Authorization': `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+      ...options.headers,
+    },
+  });
+}
+
+/**
+ * Request confirmation and poll until user responds.
+ *
+ * @param {Object} values - Parsed CLI values
+ * @param {string[]} positionals - Positional arguments
+ */
+export async function requestConfirmation(values, positionals) {
+  const type = values.type;
+  const title = values.title;
+  const content = values.content;
+  const metadataStr = values.metadata;
+  const taskArg = values.task;
+
+  // Validate required fields
+  if (!type || !title || !content) {
+    console.error(red('Error: --type, --title, and --content are required.'));
+    console.error('');
+    console.error('Usage:');
+    console.error('  push-todo confirm --type "social_post" --title "Reply to @user" --content "Your reply text..."');
+    console.error('');
+    console.error('Options:');
+    console.error('  --type      Confirmation category (social_post, email, publish, etc.)');
+    console.error('  --title     Short description of the action');
+    console.error('  --content   The actual content to be confirmed');
+    console.error('  --metadata  Optional JSON metadata for rich rendering');
+    console.error('  --task      Display number (auto-detected from PUSH_DISPLAY_NUMBER)');
+    process.exit(1);
+  }
+
+  // Resolve display number: explicit --task > PUSH_DISPLAY_NUMBER env
+  let displayNumber = taskArg ? parseInt(taskArg, 10) : null;
+  let todoId = null;
+
+  if (!displayNumber) {
+    const envDisplayNumber = process.env.PUSH_DISPLAY_NUMBER;
+    if (envDisplayNumber) {
+      displayNumber = parseInt(envDisplayNumber, 10);
+    }
+  }
+
+  if (!displayNumber) {
+    todoId = process.env.PUSH_TASK_ID || null;
+  }
+
+  if (!displayNumber && !todoId) {
+    console.error(red('Error: Cannot determine task. Use --task <number> or set PUSH_DISPLAY_NUMBER env.'));
+    process.exit(1);
+  }
+
+  // Parse metadata if provided
+  let metadata = null;
+  if (metadataStr) {
+    try {
+      metadata = JSON.parse(metadataStr);
+    } catch {
+      console.error(red('Error: --metadata must be valid JSON.'));
+      process.exit(1);
+    }
+  }
+
+  const machineName = getMachineName() || null;
+
+  // Build request payload
+  const payload = {
+    type,
+    title,
+    body: content,
+  };
+  if (displayNumber) payload.displayNumber = displayNumber;
+  if (todoId) payload.todoId = todoId;
+  if (metadata) payload.metadata = metadata;
+  if (machineName) payload.machineName = machineName;
+
+  // Send confirmation request
+  console.error(`[push-confirm] Requesting confirmation for task #${displayNumber || '?'}...`);
+  console.error(`[push-confirm] Type: ${type}`);
+  console.error(`[push-confirm] Title: ${title}`);
+  console.error(`[push-confirm] Content: ${content.slice(0, 100)}${content.length > 100 ? '...' : ''}`);
+
+  let confirmationId;
+  try {
+    const response = await apiRequest('request-confirmation', {
+      method: 'POST',
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      console.error(red(`[push-confirm] Failed to request confirmation: ${text}`));
+      // Output JSON for Claude to parse
+      console.log(JSON.stringify({ approved: false, error: `Request failed: ${text}` }));
+      process.exit(1);
+    }
+
+    const data = await response.json();
+    confirmationId = data.confirmationId;
+    console.error(`[push-confirm] Confirmation ID: ${confirmationId}`);
+    console.error(`[push-confirm] Waiting for user response on iPhone...`);
+  } catch (err) {
+    console.error(red(`[push-confirm] Error: ${err.message}`));
+    console.log(JSON.stringify({ approved: false, error: err.message }));
+    process.exit(1);
+  }
+
+  // Poll for response
+  const taskFilter = displayNumber
+    ? `display_number=${displayNumber}`
+    : `todo_id=${todoId}`;
+
+  while (true) {
+    try {
+      const response = await apiRequest(`synced-todos?${taskFilter}`);
+
+      if (!response.ok) {
+        console.error(dim(`[push-confirm] Poll error (${response.status}), retrying...`));
+        await sleep(POLL_INTERVAL_MS);
+        continue;
+      }
+
+      const data = await response.json();
+      const todos = data.todos || [];
+
+      if (todos.length === 0) {
+        console.error(dim(`[push-confirm] Task not found, retrying...`));
+        await sleep(POLL_INTERVAL_MS);
+        continue;
+      }
+
+      const todo = todos[0];
+
+      // Check if confirmation was responded to
+      if (todo.executionStatus !== 'awaiting_confirmation') {
+        // Confirmation was responded to — check events for the result
+        const approved = wasApproved(todo, confirmationId);
+
+        if (approved) {
+          console.error(green(`[push-confirm] Approved by user.`));
+          console.log(JSON.stringify({ approved: true, message: 'Confirmed by user' }));
+          process.exit(0);
+        } else {
+          console.error(yellow(`[push-confirm] Rejected by user.`));
+          console.log(JSON.stringify({ approved: false, message: 'Rejected by user' }));
+          process.exit(1);
+        }
+      }
+
+      // Still waiting
+      await sleep(POLL_INTERVAL_MS);
+    } catch (err) {
+      console.error(dim(`[push-confirm] Poll error: ${err.message}, retrying...`));
+      await sleep(POLL_INTERVAL_MS);
+    }
+  }
+}
+
+/**
+ * Check execution events to determine if confirmation was approved.
+ */
+function wasApproved(todo, confirmationId) {
+  try {
+    const events = todo.executionEventsJson
+      ? (typeof todo.executionEventsJson === 'string'
+        ? JSON.parse(todo.executionEventsJson)
+        : todo.executionEventsJson)
+      : [];
+
+    // Find the most recent confirmation response event
+    for (let i = events.length - 1; i >= 0; i--) {
+      const event = events[i];
+      if (event.type === 'confirmation_approved') {
+        return true;
+      }
+      if (event.type === 'confirmation_rejected') {
+        return false;
+      }
+    }
+  } catch {
+    // Parse error — fall through
+  }
+
+  // If no event found but status changed from awaiting_confirmation,
+  // check if pendingConfirmation was cleared (approved is more likely)
+  return !todo.pendingConfirmation;
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/lib/connect.js

@@ -12,7 +12,7 @@
  * Ported from: plugins/push-todo/scripts/connect.py (1866 lines)
  */
 
-import { execSync, spawnSync, spawn } from 'child_process';
+import { execSync, execFileSync, spawnSync, spawn } from 'child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync, statSync } from 'fs';
 import { setTimeout as sleep } from 'timers/promises';
 import { homedir } from 'os';
@@ -953,10 +953,98 @@ async function registerProjectWithBackend(apiKey, clientType = 'claude-code', ke
 const CLIENT_TO_ACTION_TYPE = {
   'claude-code': 'claude-code',
   'openai-codex': 'openai-codex',
-  'openclaw': 'clawdbot',
-  'clawdbot': 'clawdbot',
+  'openclaw': 'openclaw',
+  'clawdbot': 'openclaw',  // legacy alias
+};
+
+// ============================================================================
+// AGENT CALLER DETECTION
+// ============================================================================
+// See: /docs/20260212_agent_caller_identity_detection_investigation_and_implementation_plan.md
+
+// Known agent process names -> client_type mapping
+const PROCESS_NAME_TO_CLIENT = {
+  'claude': 'claude-code',
+  'openclaw': 'openclaw',
+  'openclaw-tui': 'openclaw',
+  'codex': 'openai-codex',
 };
 
+/**
+ * Walk up the process tree and collect ancestor process names.
+ * Uses execFileSync (no shell) for safety. Works on macOS and Linux.
+ */
+function getAncestorProcessNames(maxDepth = 8) {
+  const names = [];
+  let pid = process.ppid;
+
+  for (let i = 0; i < maxDepth && pid > 1; i++) {
+    try {
+      const info = execFileSync('ps', ['-o', 'ppid=,comm=', '-p', String(pid)], {
+        encoding: 'utf8',
+        timeout: 1000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+
+      const match = info.match(/^\s*(\d+)\s+(.+)$/);
+      if (!match) break;
+
+      const comm = match[2].trim();
+      const name = comm.split('/').pop();
+      names.push(name);
+      pid = parseInt(match[1]);
+    } catch {
+      break;
+    }
+  }
+
+  return names;
+}
+
+/**
+ * Detect which AI agent is calling us.
+ *
+ * Detection layers (in order of reliability):
+ * 1. Explicit --client flag (manual override, always wins)
+ * 2. Environment variables (agent explicitly identifies itself)
+ * 3. Process tree inspection (universal, no agent cooperation needed)
+ * 4. Default to 'claude-code' (backward compatibility)
+ *
+ * @param {string|undefined} explicitClient - Value from --client flag
+ * @returns {{ clientType: string, method: string }}
+ */
+function detectCallerAgent(explicitClient) {
+  // Layer 1: Explicit --client flag always wins
+  if (explicitClient) {
+    return { clientType: explicitClient, method: 'flag' };
+  }
+
+  // Layer 2: Known environment variables
+  if (process.env.CLAUDECODE === '1') {
+    return { clientType: 'claude-code', method: 'env' };
+  }
+
+  // Layer 3: Process tree inspection
+  try {
+    const ancestors = getAncestorProcessNames();
+    for (const name of ancestors) {
+      if (PROCESS_NAME_TO_CLIENT[name]) {
+        return { clientType: PROCESS_NAME_TO_CLIENT[name], method: 'process-tree' };
+      }
+      for (const [processName, clientType] of Object.entries(PROCESS_NAME_TO_CLIENT)) {
+        if (name.startsWith(processName)) {
+          return { clientType, method: 'process-tree' };
+        }
+      }
+    }
+  } catch {
+    // Process tree inspection failed — continue to default
+  }
+
+  // Layer 4: Default (backward compatibility)
+  return { clientType: 'claude-code', method: 'default' };
+}
+
 /**
  * Register project in local registry for daemon routing.
  *
@@ -1053,8 +1141,9 @@ export async function runConnect(options = {}) {
   // Self-healing: ensure daemon is running
   ensureDaemonRunning();
 
-  // Auto-detect client type from installation method
-  let clientType = options.client || 'claude-code';
+  // Auto-detect calling agent (Claude Code, OpenClaw, Codex, etc.)
+  const detection = detectCallerAgent(options.client);
+  let clientType = detection.clientType;
   const clientName = CLIENT_NAMES[clientType] || 'Claude Code';
 
   // Handle --check-version (JSON output)
@@ -1112,6 +1201,9 @@ export async function runConnect(options = {}) {
   console.log('');
   console.log(`  Push Voice Tasks Connect`);
   console.log('  ' + '='.repeat(40));
+  if (detection.method !== 'default') {
+    console.log(`  Agent: ${clientName} (detected via ${detection.method})`);
+  }
   console.log('');
 
   // Step 1: Check for updates

package/lib/daemon.js

@@ -1152,6 +1152,10 @@ function monitorTaskStdout(displayNumber, proc) {
 }
 
 function checkTaskIdle(displayNumber) {
+  // Skip idle check for tasks awaiting user confirmation
+  const info = taskDetails.get(displayNumber) || {};
+  if (info.phase === 'awaiting_confirmation') return false;
+
   const lastOutput = taskLastOutput.get(displayNumber);
   if (!lastOutput) return false;
 
@@ -1393,6 +1397,14 @@ IMPORTANT:
           if (buffer.length > 20) buffer.shift();
           taskStdoutBuffer.set(displayNumber, buffer);
 
+          // Detect confirmation waiting (exempt from timeouts)
+          if (line.includes('[push-confirm] Waiting for')) {
+            updateTaskDetail(displayNumber, {
+              phase: 'awaiting_confirmation',
+              detail: 'Waiting for user confirmation on iPhone'
+            });
+          }
+
           const stuckReason = checkStuckPatterns(displayNumber, line);
           if (stuckReason) {
             log(`Task #${displayNumber} may be stuck: ${stuckReason}`);
@@ -1675,6 +1687,13 @@ async function checkTimeouts() {
   const timedOut = [];
 
   for (const [displayNumber, taskInfo] of runningTasks) {
+    const info = taskDetails.get(displayNumber) || {};
+
+    // Skip timeout checks for tasks awaiting user confirmation on iPhone
+    if (info.phase === 'awaiting_confirmation') {
+      continue;
+    }
+
     const elapsed = now - taskInfo.startTime;
 
     if (elapsed > TASK_TIMEOUT_MS) {

package/lib/fetch.js

@@ -58,13 +58,22 @@ function decryptTaskFields(task) {
  * @returns {Promise<void>}
  */
 export async function listTasks(options = {}) {
-  // Determine git remote
+  // Determine git remote and action type for scoping
   let gitRemote = null;
+  let actionType = null;
   if (!options.allProjects) {
     gitRemote = getGitRemote();
     if (!gitRemote && isGitRepo()) {
       console.error(yellow('Warning: In a git repo but no remote configured.'));
     }
+    // Look up action type from project registry for proper multi-agent scoping
+    if (gitRemote) {
+      const registry = getRegistry();
+      const project = registry.findProject(gitRemote);
+      if (project) {
+        actionType = project.actionType;
+      }
+    }
   }
 
   // Fetch tasks
@@ -72,7 +81,8 @@ export async function listTasks(options = {}) {
     backlogOnly: options.backlog,
     includeBacklog: options.includeBacklog,
     completedOnly: options.completed,
-    includeCompleted: options.includeCompleted
+    includeCompleted: options.includeCompleted,
+    actionType,
   });
 
   // Decrypt if E2EE is available

package/lib/project-registry.js

@@ -103,7 +103,7 @@ class ProjectRegistry {
    * Format: "gitRemote::actionType" (e.g., "github.com/user/repo::claude-code")
    *
    * @param {string} gitRemote - Normalized git remote
-   * @param {string} actionType - Action type (e.g., "claude-code", "clawdbot")
+   * @param {string} actionType - Action type (e.g., "claude-code", "openclaw")
    * @returns {string}
    */
   _makeKey(gitRemote, actionType) {
@@ -116,7 +116,7 @@ class ProjectRegistry {
    * @param {string} gitRemote - Normalized git remote (e.g., "github.com/user/repo")
    * @param {string} localPath - Absolute local path
    * @param {Object} [actionMeta] - Action metadata from register-project response
-   * @param {string} [actionMeta.actionType] - Action type (e.g., "claude-code", "clawdbot")
+   * @param {string} [actionMeta.actionType] - Action type (e.g., "claude-code", "openclaw")
    * @param {string} [actionMeta.actionId] - Action UUID
    * @param {string} [actionMeta.actionName] - Action display name
    * @returns {boolean} True if newly registered, false if updated existing
@@ -345,6 +345,18 @@ class ProjectRegistry {
     return Object.keys(this._data.projects).length;
   }
 
+  /**
+   * Find a project entry by gitRemote and optional actionType.
+   * Public wrapper for _findProject.
+   *
+   * @param {string} gitRemote
+   * @param {string} [actionType]
+   * @returns {Object|null} Project entry with {gitRemote, localPath, actionType, ...}
+   */
+  findProject(gitRemote, actionType) {
+    return this._findProject(gitRemote, actionType);
+  }
+
   /**
    * Check if a project is registered.
    * Checks both composite keys and plain gitRemote.

package/package.json

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