@masslessai/push-todo 3.0.0 → 3.2.0

package/lib/cli.js

@@ -5,13 +5,17 @@
  */
 
 import { parseArgs } from 'util';
+import { spawn } from 'child_process';
 import * as fetch from './fetch.js';
+import * as api from './api.js';
 import { runConnect } from './connect.js';
 import { startWatch } from './watch.js';
-import { showSettings, toggleSetting } from './config.js';
-import { bold, red, cyan, dim } from './utils/colors.js';
+import { showSettings, toggleSetting, setMaxBatchSize } from './config.js';
+import { ensureDaemonRunning, getDaemonStatus, startDaemon, stopDaemon } from './daemon-health.js';
+import { getScreenshotPath, screenshotExists, openScreenshot } from './utils/screenshots.js';
+import { bold, red, cyan, dim, green } from './utils/colors.js';
 
-const VERSION = '3.0.0';
+const VERSION = '3.2.0';
 
 const HELP_TEXT = `
 ${bold('push-todo')} - Voice tasks from Push iOS app for Claude Code
@@ -36,7 +40,17 @@ ${bold('OPTIONS:')}
   --search <query>                 Search tasks
   --status                         Show connection and daemon status
   --watch, -w                      Live terminal UI
+  --follow, -f                     With --watch: exit when all tasks complete
   --setting [name]                 Show or toggle settings
+  --resume <number>                Resume Claude session for a completed task
+  --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)
+  --set-batch-size <N>             Set max tasks for batch queue (1-20)
+  --daemon-status                  Show daemon status
+  --daemon-start                   Start daemon manually
+  --daemon-stop                    Stop daemon
+  --commands                       Show available user commands
   --json                           Output as JSON
   --version, -v                    Show version
   --help, -h                       Show this help
@@ -49,6 +63,17 @@ ${bold('EXAMPLES:')}
   push-todo search "auth bug"      Search for tasks matching "auth bug"
   push-todo connect                Run connection diagnostics
 
+${bold('CONNECT OPTIONS:')}
+  --reauth                         Force re-authentication
+  --client <type>                  Client type (claude-code, openai-codex, clawdbot)
+  --check-version                  Check for updates (JSON output)
+  --update                         Update to latest version
+  --validate-key                   Validate API key (JSON output)
+  --validate-machine               Validate machine registration (JSON output)
+  --validate-project               Validate project registration (JSON output)
+  --store-e2ee-key <key>           Import E2EE encryption key
+  --description <text>             Project description (with connect)
+
 ${bold('SETTINGS:')}
   push-todo setting                Show all settings
   push-todo setting auto-commit    Toggle auto-commit
@@ -69,10 +94,30 @@ const options = {
   'search': { type: 'string' },
   'status': { type: 'boolean' },
   'watch': { type: 'boolean', short: 'w' },
+  'follow': { type: 'boolean', short: 'f' },
   'setting': { type: 'string' },
+  'resume': { type: 'string' },
+  'view-screenshot': { type: 'string' },
+  'learn-vocabulary': { type: 'string' },
+  'keywords': { type: 'string' },
+  'set-batch-size': { type: 'string' },
+  'daemon-status': { type: 'boolean' },
+  'daemon-start': { type: 'boolean' },
+  'daemon-stop': { type: 'boolean' },
+  'commands': { type: 'boolean' },
   'json': { type: 'boolean' },
   'version': { type: 'boolean', short: 'v' },
-  'help': { type: 'boolean', short: 'h' }
+  'help': { type: 'boolean', short: 'h' },
+  // Connect options
+  'reauth': { type: 'boolean' },
+  'client': { type: 'string' },
+  'check-version': { type: 'boolean' },
+  'update': { type: 'boolean' },
+  'validate-key': { type: 'boolean' },
+  'validate-machine': { type: 'boolean' },
+  'validate-project': { type: 'boolean' },
+  'store-e2ee-key': { type: 'string' },
+  'description': { type: 'string' }
 };
 
 /**
@@ -115,6 +160,258 @@ export async function run(argv) {
     return;
   }
 
+  // Daemon management commands (don't auto-start daemon for these)
+  if (values['daemon-status']) {
+    const status = getDaemonStatus();
+    if (status.running) {
+      console.log(`${bold('Daemon:')} Running (PID: ${status.pid})`);
+      if (status.uptime) console.log(`${dim('Uptime:')} ${status.uptime}`);
+      if (status.version) console.log(`${dim('Version:')} ${status.version}`);
+      if (status.runningTasks?.length > 0) {
+        console.log(`\n${bold('Running Tasks:')}`);
+        for (const t of status.runningTasks) {
+          console.log(`  #${t.displayNumber} - ${t.summary}`);
+        }
+      }
+      if (status.completedToday?.length > 0) {
+        console.log(`\n${bold('Completed Today:')} ${status.completedToday.length} tasks`);
+      }
+    } else {
+      console.log(`${bold('Daemon:')} Not running`);
+    }
+    return;
+  }
+
+  if (values['daemon-start']) {
+    const status = getDaemonStatus();
+    if (status.running) {
+      console.log(`Daemon already running (PID: ${status.pid})`);
+    } else {
+      const success = startDaemon();
+      if (success) {
+        console.log('Daemon started');
+      } else {
+        console.error(red('Failed to start daemon'));
+        process.exit(1);
+      }
+    }
+    return;
+  }
+
+  if (values['daemon-stop']) {
+    const status = getDaemonStatus();
+    if (!status.running) {
+      console.log('Daemon is not running');
+    } else {
+      const success = stopDaemon();
+      if (success) {
+        console.log('Daemon stopped');
+      } else {
+        console.error(red('Failed to stop daemon'));
+        process.exit(1);
+      }
+    }
+    return;
+  }
+
+  // Handle --commands (simple user help)
+  if (values.commands) {
+    console.log(`
+  ${bold('Push Voice Tasks - Commands')}
+  ${'='.repeat(40)}
+
+  /push-todo              Show your active tasks
+  /push-todo 427          Work on task #427
+  /push-todo search X     Search tasks for 'X'
+  /push-todo connect      Setup or fix problems
+  /push-todo review       Check completed work
+  /push-todo status       Show connection status
+  /push-todo watch        Live monitor daemon tasks
+  /push-todo setting      View/toggle settings
+
+  ${dim('Options:')}
+  --all-projects          See tasks from all projects
+  --backlog               See deferred tasks only
+  --search "query"        Search active & completed tasks
+`);
+    return;
+  }
+
+  // Handle --set-batch-size
+  if (values['set-batch-size']) {
+    const size = parseInt(values['set-batch-size'], 10);
+    if (isNaN(size) || size < 1 || size > 20) {
+      console.error(red('Batch size must be between 1 and 20'));
+      process.exit(1);
+    }
+    if (setMaxBatchSize(size)) {
+      console.log(`Max batch size set to ${size}`);
+    } else {
+      console.error(red('Failed to set batch size'));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Handle --resume (resume Claude session for a completed task)
+  if (values.resume) {
+    const taskNum = values.resume.replace(/^#/, '');
+    const displayNumber = parseInt(taskNum, 10);
+    if (isNaN(displayNumber)) {
+      console.error(red(`Invalid task number: ${values.resume}`));
+      process.exit(1);
+    }
+
+    // Fetch task to get session_id
+    const task = await fetch.getTaskByNumber(displayNumber);
+    if (!task) {
+      console.error(red(`Task #${displayNumber} not found`));
+      process.exit(1);
+    }
+
+    const sessionId = task.execution_session_id || task.executionSessionId;
+    if (!sessionId) {
+      const executionStatus = task.execution_status || task.executionStatus;
+      if (executionStatus) {
+        console.log(`Task #${displayNumber} has execution status '${executionStatus}' but no session ID.`);
+        console.log('Session ID is captured when daemon completes a task.');
+        console.log();
+        console.log('Possible reasons:');
+        console.log('  - Task was completed before session capture was added');
+        console.log('  - Task was completed manually (not by daemon)');
+        console.log("  - Daemon couldn't extract session ID from Claude's output");
+      } else {
+        console.log(`Task #${displayNumber} was not executed by the daemon.`);
+        console.log('Session resume is only available for tasks completed by the Push daemon.');
+      }
+      process.exit(1);
+    }
+
+    // Launch claude --resume with the session ID
+    console.log(`Resuming session for task #${displayNumber}...`);
+    console.log(`Session ID: ${sessionId}`);
+    console.log();
+
+    // Use spawn with stdio: 'inherit' to give control to Claude
+    const child = spawn('claude', ['--resume', sessionId], {
+      stdio: 'inherit',
+      shell: true
+    });
+
+    child.on('error', (error) => {
+      if (error.code === 'ENOENT') {
+        console.error(red("Error: 'claude' command not found. Is Claude Code installed?"));
+      } else {
+        console.error(red(`Error launching Claude: ${error.message}`));
+      }
+      process.exit(1);
+    });
+
+    child.on('close', (code) => {
+      process.exit(code || 0);
+    });
+
+    return;
+  }
+
+  // Handle --view-screenshot (open screenshot for viewing)
+  if (values['view-screenshot']) {
+    // Get the first positional as task number (if provided)
+    const taskNum = positionals[0]?.replace(/^#/, '');
+
+    if (taskNum && /^\d+$/.test(taskNum)) {
+      // Task number provided - get task's screenshots
+      const displayNumber = parseInt(taskNum, 10);
+      const task = await fetch.getTaskByNumber(displayNumber);
+
+      if (!task) {
+        console.error(red(`Task #${displayNumber} not found`));
+        process.exit(1);
+      }
+
+      const screenshots = task.screenshot_attachments || task.screenshotAttachments || [];
+      if (screenshots.length === 0) {
+        console.error(red(`Task #${displayNumber} has no screenshot attachments`));
+        process.exit(1);
+      }
+
+      // Try to parse as index
+      let filename;
+      const idx = parseInt(values['view-screenshot'], 10);
+      if (!isNaN(idx)) {
+        if (idx < 0 || idx >= screenshots.length) {
+          console.error(red(`Screenshot index ${idx} out of range (0-${screenshots.length - 1})`));
+          process.exit(1);
+        }
+        filename = screenshots[idx].imageFilename || screenshots[idx].image_filename;
+      } else {
+        // Not an index, treat as filename
+        filename = values['view-screenshot'];
+      }
+
+      const filepath = getScreenshotPath(filename);
+      try {
+        await openScreenshot(filepath);
+      } catch (error) {
+        console.error(red(error.message));
+        process.exit(1);
+      }
+    } else {
+      // No task number, treat arg as filename
+      const filepath = getScreenshotPath(values['view-screenshot']);
+      try {
+        await openScreenshot(filepath);
+      } catch (error) {
+        console.error(red(error.message));
+        process.exit(1);
+      }
+    }
+    return;
+  }
+
+  // Handle --learn-vocabulary (contribute vocabulary terms)
+  if (values['learn-vocabulary']) {
+    if (!values.keywords) {
+      console.error(red('--keywords required with --learn-vocabulary'));
+      console.error("Example: --learn-vocabulary TASK_ID --keywords 'realtime,sync,websocket'");
+      process.exit(1);
+    }
+
+    // Parse comma-separated keywords
+    const keywords = values.keywords.split(',').map(k => k.trim()).filter(Boolean);
+    if (keywords.length === 0) {
+      console.error(red('No valid keywords provided'));
+      process.exit(1);
+    }
+
+    try {
+      const result = await api.learnVocabulary(values['learn-vocabulary'], keywords);
+
+      if (values.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        const added = result.keywords_added || [];
+        const dupes = result.keywords_duplicate || [];
+        const total = result.total_keywords || 0;
+
+        if (added.length > 0) {
+          console.log(green(`Added ${added.length} new terms: ${added.join(', ')}`));
+        }
+        if (dupes.length > 0) {
+          console.log(dim(`Already known: ${dupes.join(', ')}`));
+        }
+        console.log(`Total vocabulary: ${total} terms`);
+      }
+    } catch (error) {
+      console.error(red(`Failed to learn vocabulary: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Auto-start daemon on every command (self-healing behavior)
+  ensureDaemonRunning();
+
   // Get the command (first positional)
   const command = positionals[0];
 
@@ -128,6 +425,15 @@ export async function run(argv) {
     return fetch.runReview(values);
   }
 
+  // Setting command (positional form: push-todo setting [name])
+  if (command === 'setting') {
+    const settingName = positionals[1];
+    if (settingName) {
+      return toggleSetting(settingName);
+    }
+    return showSettings();
+  }
+
   // Search command (positional form)
   if (command === 'search' && positionals[1]) {
     return fetch.searchTasks(positionals.slice(1).join(' '), values);