@masslessai/push-todo 4.0.9 → 4.1.0

package/lib/auto-connect.js

@@ -0,0 +1,195 @@
+/**
+ * Auto-connect orchestrator for Push CLI.
+ *
+ * Scans the user's home folder for Claude Code, Codex, and OpenClaw projects,
+ * then batch-registers them all with the Push backend in one shot.
+ *
+ * Usage: push-todo connect --auto
+ */
+
+import { getApiKey, saveCredentials, getEmail } from './config.js';
+import {
+  CLIENT_TO_ACTION_TYPE,
+  registerProjectWithBackendExplicit,
+  registerProjectLocally,
+  doFullDeviceAuth,
+} from './connect.js';
+import { getRegistry } from './project-registry.js';
+import { normalizeGitRemote } from './utils/git.js';
+import { discoverAllProjects } from './discovery.js';
+import { createSpinner } from './utils/spinner.js';
+import { bold, green, red, dim, cyan } from './utils/colors.js';
+import { ensureDaemonRunning } from './daemon-health.js';
+
+/**
+ * Run the auto-connect flow.
+ *
+ * 1. Ensure authenticated
+ * 2. Scan for projects across all agents
+ * 3. Deduplicate and filter already-registered
+ * 4. Batch-register with backend + local registry
+ * 5. Display progress and summary
+ *
+ * @param {Object} options - CLI options
+ */
+export async function runAutoConnect(options = {}) {
+  // Self-healing: ensure daemon is running
+  ensureDaemonRunning();
+
+  console.log('');
+  console.log(`  ${bold('Push Auto-Connect')}`);
+  console.log(`  ${'='.repeat(40)}`);
+  console.log('');
+
+  // Phase 1: Ensure authenticated
+  let apiKey;
+  try {
+    apiKey = getApiKey();
+  } catch {
+    apiKey = null;
+  }
+  const email = getEmail();
+
+  if (!apiKey || !email) {
+    console.log('  Not authenticated. Starting auth flow...');
+    console.log('');
+    const authResult = await doFullDeviceAuth('claude-code');
+    saveCredentials(authResult.api_key, authResult.email);
+    apiKey = authResult.api_key;
+    console.log('');
+    console.log(`  ${green('✓')} Authenticated as ${authResult.email}`);
+    console.log('');
+  } else {
+    console.log(`  ${green('✓')} Authenticated as ${email}`);
+    console.log('');
+  }
+
+  // Phase 2: Scan for projects
+  console.log('  Scanning for projects...');
+
+  const spinner = createSpinner();
+
+  spinner.start('Scanning Claude Code projects...');
+  const { projects, counts } = discoverAllProjects();
+
+  // Show per-agent results
+  if (counts.claudeCode > 0) {
+    spinner.succeed(`Claude Code: ${counts.claudeCode} projects found`);
+  } else {
+    spinner.info('Claude Code: no projects found');
+  }
+
+  const spinner2 = createSpinner();
+  if (counts.codex > 0) {
+    spinner2.succeed(`Codex: ${counts.codex} projects found`);
+  } else {
+    spinner2.info('Codex: not installed or no projects');
+  }
+
+  const spinner3 = createSpinner();
+  if (counts.openclaw > 0) {
+    spinner3.succeed(`OpenClaw: ${counts.openclaw} projects found`);
+  } else {
+    spinner3.info('OpenClaw: not installed or no projects');
+  }
+
+  if (projects.length === 0) {
+    console.log('');
+    console.log('  No projects with git remotes found.');
+    console.log(`  ${dim('Projects must have a git remote to be registered.')}`);
+    console.log('');
+    return;
+  }
+
+  console.log('');
+  console.log(`  ${bold(`${projects.length} unique projects`)} to process`);
+  console.log(`  ${'─'.repeat(40)}`);
+  console.log('');
+
+  // Phase 3: Check which are already registered
+  const registry = getRegistry();
+  const toRegister = [];
+  let alreadyConnected = 0;
+
+  for (const project of projects) {
+    const actionType = CLIENT_TO_ACTION_TYPE[project.agentType] || project.agentType;
+    const existingPath = registry.getPathWithoutUpdate(project.gitRemote, actionType);
+    if (existingPath) {
+      alreadyConnected++;
+      console.log(`  ${dim('○')} ${dim(project.gitRemote)} ${dim(`(${project.agentType})`)} ${dim('— already connected')}`);
+    } else {
+      toRegister.push(project);
+    }
+  }
+
+  if (toRegister.length === 0) {
+    console.log('');
+    console.log(`  ${'='.repeat(40)}`);
+    console.log(`  All ${alreadyConnected} projects already connected.`);
+    console.log('');
+    return;
+  }
+
+  // Phase 4: Register new projects
+  let registered = 0;
+  let failed = 0;
+
+  for (const project of toRegister) {
+    const regSpinner = createSpinner();
+    const label = `${project.gitRemote} (${project.agentType})`;
+    regSpinner.start(`Registering ${label}...`);
+
+    try {
+      const result = await registerProjectWithBackendExplicit(
+        apiKey,
+        project.agentType,
+        project.projectPath,
+        project.gitRemote,
+        project.projectContext
+      );
+
+      if (result.status === 'unauthorized') {
+        regSpinner.fail(`${label} — session expired`);
+        console.log('');
+        console.log(`  ${red('Error:')} API key invalid or revoked.`);
+        console.log(`  Run ${cyan("'push-todo connect --reauth'")} to re-authenticate.`);
+        console.log('');
+        return;
+      }
+
+      if (result.status === 'success') {
+        // Register locally
+        const actionType = result.action_type || CLIENT_TO_ACTION_TYPE[project.agentType] || project.agentType;
+        registerProjectLocally(project.gitRemote, project.projectPath, {
+          actionType,
+          actionId: result.action_id,
+          actionName: result.action_name,
+        });
+        regSpinner.succeed(label);
+        registered++;
+      } else {
+        regSpinner.fail(`${label} — ${result.message || 'unknown error'}`);
+        failed++;
+      }
+    } catch (error) {
+      regSpinner.fail(`${label} — ${error.message}`);
+      failed++;
+    }
+  }
+
+  // Phase 5: Summary
+  console.log('');
+  console.log(`  ${'='.repeat(40)}`);
+
+  const parts = [];
+  if (registered > 0) parts.push(green(`${registered} registered`));
+  if (alreadyConnected > 0) parts.push(dim(`${alreadyConnected} already connected`));
+  if (failed > 0) parts.push(red(`${failed} failed`));
+
+  console.log(`  ${parts.join(', ')}`);
+
+  if (registered > 0) {
+    console.log(`  Run ${cyan("'push-todo'")} to see your tasks.`);
+  }
+  console.log('');
+}

package/lib/cli.js

@@ -95,6 +95,7 @@ ${bold('CONNECT OPTIONS:')}
   --validate-project               Validate project registration (JSON output)
   --store-e2ee-key <key>           Import E2EE encryption key
   --description <text>             Project description (with connect)
+  --auto                           Auto-discover and register all projects
 
 ${bold('CONFIRM (for daemon skills):')}
   push-todo confirm --type "social_post" --title "Post tweet" --content "..."
@@ -158,6 +159,7 @@ const options = {
   'validate-project': { type: 'boolean' },
   'store-e2ee-key': { type: 'string' },
   'description': { type: 'string' },
+  'auto': { type: 'boolean' },
   // Confirm command options
   'type': { type: 'string' },
   'title': { type: 'string' },
@@ -351,21 +353,34 @@ export async function run(argv) {
       const suffix = parts.length > 1 ? parts[parts.length - 1].slice(0, 8) : machineId.slice(0, 8);
       const worktreeName = `push-${displayNumber}-${suffix}`;
 
-      // Try to find the worktree relative to CWD's parent (sibling directory)
-      const candidate = join(dirname(process.cwd()), worktreeName);
-      if (existsSync(candidate)) {
-        resumeCwd = candidate;
-        console.log(`Found daemon worktree: ${candidate}`);
+      // Check new location first (inside project at .claude/worktrees/)
+      const newCandidate = join(process.cwd(), '.claude', 'worktrees', worktreeName);
+      // Check legacy location (sibling directory, pre-migration daemon)
+      const legacyCandidate = join(dirname(process.cwd()), worktreeName);
+
+      if (existsSync(newCandidate)) {
+        resumeCwd = newCandidate;
+        console.log(`Found daemon worktree: ${newCandidate}`);
+      } else if (existsSync(legacyCandidate)) {
+        resumeCwd = legacyCandidate;
+        console.log(`Found daemon worktree (legacy): ${legacyCandidate}`);
       } else {
         // Worktree was cleaned up after daemon finished, but the session file
         // still exists at ~/.claude/projects/. Re-create the directory so Claude
         // maps CWD to the correct session directory and finds the session.
         try {
-          mkdirSync(candidate, { recursive: true });
-          resumeCwd = candidate;
-          console.log(`Re-created worktree directory for session lookup: ${candidate}`);
+          mkdirSync(newCandidate, { recursive: true });
+          resumeCwd = newCandidate;
+          console.log(`Re-created worktree directory for session lookup: ${newCandidate}`);
         } catch {
-          console.log(dim(`Could not create worktree dir at ${candidate}, using current directory`));
+          // Fall back to legacy location
+          try {
+            mkdirSync(legacyCandidate, { recursive: true });
+            resumeCwd = legacyCandidate;
+            console.log(`Re-created worktree directory for session lookup: ${legacyCandidate}`);
+          } catch {
+            console.log(dim(`Could not create worktree dir, using current directory`));
+          }
         }
       }
     } catch {
@@ -633,6 +648,10 @@ export async function run(argv) {
 
   // Connect command
   if (command === 'connect') {
+    if (values.auto) {
+      const { runAutoConnect } = await import('./auto-connect.js');
+      return runAutoConnect(values);
+    }
     return runConnect(values);
   }
 

package/lib/connect.js

@@ -950,7 +950,7 @@ async function registerProjectWithBackend(apiKey, clientType = 'claude-code', ke
 
 // Mapping from CLI client_type to canonical DB action_type
 // Must match CLIENT_TO_ACTION_TYPE in register-project edge function
-const CLIENT_TO_ACTION_TYPE = {
+export const CLIENT_TO_ACTION_TYPE = {
   'claude-code': 'claude-code',
   'openai-codex': 'openai-codex',
   'openclaw': 'openclaw',
@@ -1378,6 +1378,65 @@ export async function runConnect(options = {}) {
   console.log('');
 }
 
+/**
+ * Register a project with the backend using explicit path and remote.
+ * Used by auto-connect for registering discovered projects at arbitrary paths.
+ *
+ * @param {string} apiKey - Push API key
+ * @param {string} clientType - Agent type (claude-code, openai-codex, openclaw)
+ * @param {string} projectPath - Absolute path to the project
+ * @param {string} gitRemote - Raw git remote URL
+ * @param {string|null} projectContext - First 50 lines of CLAUDE.md/README.md for keyword generation
+ * @returns {Promise<Object>} Registration result with status, action_id, action_type, etc.
+ */
+async function registerProjectWithBackendExplicit(apiKey, clientType, projectPath, gitRemote, projectContext = null) {
+  const clientName = CLIENT_NAMES[clientType] || 'Claude Code';
+
+  const payload = {
+    client_type: clientType,
+    client_name: clientName,
+    device_name: getDeviceName(),
+    project_path: projectPath,
+    git_remote: gitRemote,
+  };
+
+  if (projectContext) {
+    payload.project_context = projectContext;
+  }
+
+  const response = await fetch(`${API_BASE}/register-project`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'apikey': ANON_KEY,
+      'Authorization': `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(payload)
+  });
+
+  if (!response.ok) {
+    if (response.status === 401) {
+      return { status: 'unauthorized', message: 'API key invalid or revoked' };
+    }
+    const body = await response.json().catch(() => ({}));
+    return { status: 'error', message: body.error_description || `HTTP ${response.status}` };
+  }
+
+  const data = await response.json();
+  if (data.success) {
+    return {
+      status: 'success',
+      action_id: data.action_id || null,
+      action_type: data.action_type || null,
+      action_name: data.normalized_name || data.action_name || 'Unknown',
+      created: data.created !== false,
+      message: data.message || ''
+    };
+  }
+
+  return { status: 'error', message: 'Unknown error' };
+}
+
 export {
   checkVersion,
   doUpdate,
@@ -1388,5 +1447,9 @@ export {
   storeE2EEKeyDirect,
   showStatus,
   getInstallationMethod,
+  registerProjectWithBackendExplicit,
+  registerProjectLocally,
+  doFullDeviceAuth,
+  CLIENT_NAMES,
   VERSION
 };

package/lib/discovery.js

@@ -0,0 +1,334 @@
+/**
+ * Project Discovery Engine for Push CLI.
+ *
+ * Scans the user's home folder for projects used with Claude Code, Codex,
+ * and OpenClaw. Returns deduplicated list of (gitRemote, agentType) pairs.
+ *
+ * Discovery sources:
+ * - Claude Code: ~/.claude/projects/ (sessions-index.json or path decode)
+ * - Codex: ~/.codex/sessions/ (JSONL first-line cwd extraction)
+ * - OpenClaw: ~/.openclaw/agents/main/sessions/ (JSONL first-line cwd)
+ */
+
+import { readdirSync, readFileSync, existsSync, statSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { getGitRemoteForPath, normalizeGitRemote } from './utils/git.js';
+
+/**
+ * @typedef {Object} DiscoveredProject
+ * @property {string} projectPath - Absolute path to the project directory
+ * @property {string} gitRemote - Normalized git remote URL
+ * @property {string} agentType - 'claude-code' | 'openai-codex' | 'openclaw'
+ * @property {string} source - Human-readable description of discovery source
+ * @property {string|null} projectContext - First 50 lines of CLAUDE.md or README.md (for keyword generation)
+ */
+
+// ============================================================================
+// CLAUDE CODE DISCOVERY
+// ============================================================================
+
+/**
+ * Discover projects from Claude Code's ~/.claude/projects/ directory.
+ *
+ * Strategy:
+ * 1. List all dirs, skip worktree dirs (contain '--claude-worktrees')
+ * 2. For dirs WITH sessions-index.json: extract unique projectPaths
+ * 3. For dirs WITHOUT: decode path naively (replace - with /)
+ * 4. Verify each path exists and has a git remote
+ *
+ * @returns {DiscoveredProject[]}
+ */
+export function discoverClaudeCodeProjects() {
+  const projectsDir = join(homedir(), '.claude', 'projects');
+  if (!existsSync(projectsDir)) return [];
+
+  const results = [];
+  const seenPaths = new Set();
+
+  let dirs;
+  try {
+    dirs = readdirSync(projectsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+  } catch {
+    return [];
+  }
+
+  for (const dirName of dirs) {
+    // Skip worktree dirs
+    if (dirName.includes('--claude-worktrees')) continue;
+
+    const dirPath = join(projectsDir, dirName);
+
+    // Try sessions-index.json first (most reliable — contains real projectPath)
+    const indexPath = join(dirPath, 'sessions-index.json');
+    if (existsSync(indexPath)) {
+      try {
+        const data = JSON.parse(readFileSync(indexPath, 'utf8'));
+        if (data.entries && Array.isArray(data.entries)) {
+          for (const entry of data.entries) {
+            if (entry.projectPath && !seenPaths.has(entry.projectPath)) {
+              seenPaths.add(entry.projectPath);
+              addIfValid(results, entry.projectPath, 'claude-code', 'Claude Code session');
+            }
+          }
+        }
+        continue; // sessions-index.json handled this dir
+      } catch {
+        // Fall through to naive decode
+      }
+    }
+
+    // Fallback: naive path decode
+    // -Users-yuxianggu-projects-AppleWhisper → /Users/yuxianggu/projects/AppleWhisper
+    // This is lossy for paths containing hyphens, but we verify existence
+    if (dirName.startsWith('-')) {
+      const decoded = '/' + dirName.slice(1).replace(/-/g, '/');
+      if (!seenPaths.has(decoded) && existsSync(decoded)) {
+        seenPaths.add(decoded);
+        addIfValid(results, decoded, 'claude-code', 'Claude Code project');
+      }
+    }
+  }
+
+  return results;
+}
+
+// ============================================================================
+// CODEX DISCOVERY
+// ============================================================================
+
+/**
+ * Discover projects from Codex's ~/.codex/sessions/ directory.
+ *
+ * Strategy:
+ * 1. Recursively find *.jsonl files under ~/.codex/sessions/
+ * 2. Read first line, parse JSON, extract payload.cwd
+ * 3. Verify each path exists and has a git remote
+ *
+ * @returns {DiscoveredProject[]}
+ */
+export function discoverCodexProjects() {
+  const sessionsDir = join(homedir(), '.codex', 'sessions');
+  if (!existsSync(sessionsDir)) return [];
+
+  const results = [];
+  const seenPaths = new Set();
+
+  const jsonlFiles = findJsonlFiles(sessionsDir);
+
+  for (const filePath of jsonlFiles) {
+    const cwd = extractCwdFromJsonl(filePath, 'codex');
+    if (cwd && !seenPaths.has(cwd)) {
+      seenPaths.add(cwd);
+      addIfValid(results, cwd, 'openai-codex', 'Codex session');
+    }
+  }
+
+  return results;
+}
+
+// ============================================================================
+// OPENCLAW DISCOVERY
+// ============================================================================
+
+/**
+ * Discover projects from OpenClaw's session files.
+ *
+ * Strategy:
+ * 1. Read *.jsonl files from ~/.openclaw/agents/main/sessions/
+ * 2. Extract cwd from first line
+ * 3. Skip generic workspace (~/.openclaw/workspace) — not a real project
+ * 4. Verify each path exists and has a git remote
+ *
+ * @returns {DiscoveredProject[]}
+ */
+export function discoverOpenClawProjects() {
+  const sessionsDir = join(homedir(), '.openclaw', 'agents', 'main', 'sessions');
+  if (!existsSync(sessionsDir)) return [];
+
+  const results = [];
+  const seenPaths = new Set();
+  const workspacePath = join(homedir(), '.openclaw', 'workspace');
+
+  let files;
+  try {
+    files = readdirSync(sessionsDir).filter(f => f.endsWith('.jsonl') && !f.includes('.deleted.'));
+  } catch {
+    return [];
+  }
+
+  for (const fileName of files) {
+    const filePath = join(sessionsDir, fileName);
+    const cwd = extractCwdFromJsonl(filePath, 'openclaw');
+    if (cwd && cwd !== workspacePath && !seenPaths.has(cwd)) {
+      seenPaths.add(cwd);
+      addIfValid(results, cwd, 'openclaw', 'OpenClaw session');
+    }
+  }
+
+  return results;
+}
+
+// ============================================================================
+// UNIFIED DISCOVERY
+// ============================================================================
+
+/**
+ * Discover all projects from all supported agents.
+ *
+ * Runs each agent's scanner and deduplicates results by (gitRemote, agentType).
+ *
+ * @returns {{ projects: DiscoveredProject[], counts: { claudeCode: number, codex: number, openclaw: number } }}
+ */
+export function discoverAllProjects() {
+  const claudeCode = discoverClaudeCodeProjects();
+  const codex = discoverCodexProjects();
+  const openclaw = discoverOpenClawProjects();
+
+  const all = [...claudeCode, ...codex, ...openclaw];
+  const deduplicated = deduplicateProjects(all);
+
+  return {
+    projects: deduplicated,
+    counts: {
+      claudeCode: claudeCode.length,
+      codex: codex.length,
+      openclaw: openclaw.length,
+    }
+  };
+}
+
+/**
+ * Deduplicate discovered projects by (gitRemote, agentType) pair.
+ *
+ * @param {DiscoveredProject[]} projects
+ * @returns {DiscoveredProject[]}
+ */
+export function deduplicateProjects(projects) {
+  const seen = new Map();
+
+  for (const project of projects) {
+    const key = `${project.gitRemote}::${project.agentType}`;
+    if (!seen.has(key)) {
+      seen.set(key, project);
+    }
+  }
+
+  return Array.from(seen.values());
+}
+
+// ============================================================================
+// HELPERS
+// ============================================================================
+
+/**
+ * Check if a path is a valid project with a git remote, and add to results if so.
+ *
+ * @param {DiscoveredProject[]} results - Array to push to
+ * @param {string} projectPath - Absolute path to check
+ * @param {string} agentType - Agent type identifier
+ * @param {string} source - Human-readable source description
+ */
+function addIfValid(results, projectPath, agentType, source) {
+  if (!existsSync(projectPath)) return;
+
+  // Check it's a directory
+  try {
+    if (!statSync(projectPath).isDirectory()) return;
+  } catch {
+    return;
+  }
+
+  const gitRemote = getGitRemoteForPath(projectPath);
+  if (!gitRemote) return;
+
+  const projectContext = readProjectContext(projectPath);
+  results.push({ projectPath, gitRemote, agentType, source, projectContext });
+}
+
+/**
+ * Read project context for keyword generation.
+ *
+ * Tries CLAUDE.md first (richer, written for AI), then README.md.
+ * Returns first 50 lines or null if neither exists.
+ *
+ * @param {string} projectPath - Absolute path to the project
+ * @returns {string|null} First 50 lines of project documentation
+ */
+function readProjectContext(projectPath) {
+  for (const filename of ['CLAUDE.md', 'README.md']) {
+    const filePath = join(projectPath, filename);
+    if (!existsSync(filePath)) continue;
+
+    try {
+      const content = readFileSync(filePath, 'utf8');
+      const lines = content.split('\n').slice(0, 50);
+      const text = lines.join('\n').trim();
+      if (text.length > 0) return text;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract cwd from the first line of a JSONL session file.
+ *
+ * Handles two formats:
+ * - Codex: {"type":"session_meta","payload":{"cwd":"/path",...}}
+ * - OpenClaw: {"type":"session","cwd":"/path",...}
+ *
+ * @param {string} filePath - Absolute path to the JSONL file
+ * @param {'codex'|'openclaw'} format - Which format to expect
+ * @returns {string|null} The cwd value or null
+ */
+function extractCwdFromJsonl(filePath, format) {
+  try {
+    const content = readFileSync(filePath, 'utf8');
+    const firstLine = content.split('\n')[0];
+    if (!firstLine) return null;
+
+    const data = JSON.parse(firstLine);
+
+    if (format === 'codex') {
+      return data?.payload?.cwd || null;
+    }
+    // openclaw
+    return data?.cwd || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Recursively find all .jsonl files in a directory.
+ *
+ * @param {string} dir - Directory to search
+ * @param {number} maxDepth - Maximum recursion depth
+ * @returns {string[]}
+ */
+function findJsonlFiles(dir, maxDepth = 5) {
+  if (maxDepth <= 0) return [];
+
+  const results = [];
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...findJsonlFiles(fullPath, maxDepth - 1));
+    } else if (entry.name.endsWith('.jsonl') && !entry.name.includes('.deleted.')) {
+      results.push(fullPath);
+    }
+  }
+
+  return results;
+}

package/lib/utils/git.js

@@ -4,7 +4,7 @@
  * Provides helpers for git operations like getting remote URLs.
  */
 
-import { execSync } from 'child_process';
+import { execSync, execFileSync } from 'child_process';
 
 /**
  * Get the normalized git remote URL for the current directory.
@@ -148,6 +148,31 @@ export function hasUncommittedChanges() {
   }
 }
 
+/**
+ * Get the normalized git remote URL for a specific directory path.
+ *
+ * Uses execFileSync (no shell) for safe execution with untrusted paths.
+ *
+ * @param {string} projectPath - Absolute path to the project directory
+ * @returns {string|null} Normalized git remote or null if not a git repo / no remote
+ */
+export function getGitRemoteForPath(projectPath) {
+  try {
+    const result = execFileSync('git', ['-C', projectPath, 'remote', 'get-url', 'origin'], {
+      encoding: 'utf8',
+      timeout: 5000,
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    const url = result.trim();
+    if (!url) return null;
+
+    return normalizeGitRemote(url);
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Normalize a git remote URL to a consistent format.
  *

package/lib/utils/spinner.js

@@ -0,0 +1,73 @@
+/**
+ * Simple ANSI spinner for Push CLI.
+ *
+ * Braille-frame spinner that overwrites a single terminal line.
+ * Uses the same ANSI patterns as watch.js (no external dependencies).
+ */
+
+import { codes } from './colors.js';
+
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const INTERVAL_MS = 80;
+
+/**
+ * Create a spinner that updates in-place on a single line.
+ *
+ * @returns {{ start(text: string): void, update(text: string): void, succeed(text: string): void, fail(text: string): void, stop(): void }}
+ */
+export function createSpinner() {
+  let frameIndex = 0;
+  let intervalId = null;
+  let currentText = '';
+
+  function render() {
+    const frame = `${codes.cyan}${FRAMES[frameIndex]}${codes.reset}`;
+    process.stdout.write(`\r${codes.clearLine}  ${frame} ${currentText}`);
+    frameIndex = (frameIndex + 1) % FRAMES.length;
+  }
+
+  return {
+    start(text) {
+      currentText = text;
+      frameIndex = 0;
+      render();
+      intervalId = setInterval(render, INTERVAL_MS);
+    },
+
+    update(text) {
+      currentText = text;
+    },
+
+    succeed(text) {
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      process.stdout.write(`\r${codes.clearLine}  ${codes.green}✓${codes.reset} ${text}\n`);
+    },
+
+    fail(text) {
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      process.stdout.write(`\r${codes.clearLine}  ${codes.red}✗${codes.reset} ${text}\n`);
+    },
+
+    info(text) {
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      process.stdout.write(`\r${codes.clearLine}  ${codes.dim}○${codes.reset} ${text}\n`);
+    },
+
+    stop() {
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      process.stdout.write(`\r${codes.clearLine}`);
+    }
+  };
+}

package/package.json

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