@masslessai/push-todo 3.0.0

package/lib/watch.js

@@ -0,0 +1,343 @@
+/**
+ * Live terminal UI for Push CLI.
+ *
+ * Displays real-time daemon status and task execution progress.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import readline from 'readline';
+import { codes, colorsEnabled } from './utils/colors.js';
+import { formatDuration, truncate } from './utils/format.js';
+
+const STATUS_FILE = join(homedir(), '.push', 'daemon_status.json');
+const REFRESH_INTERVAL = 500; // ms
+
+/**
+ * Read the current daemon status from file.
+ *
+ * @returns {Object|null} Status object or null if unavailable
+ */
+function readStatus() {
+  if (!existsSync(STATUS_FILE)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(STATUS_FILE, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Format a task status line for display.
+ *
+ * @param {Object} task - Task status object
+ * @returns {string} Formatted status line
+ */
+function formatTaskLine(task) {
+  const num = `#${task.displayNumber || '?'}`.padEnd(5);
+  const summary = truncate(task.summary || 'Unknown', 40);
+
+  let statusIcon = '○';
+  let statusColor = codes.yellow;
+
+  switch (task.status) {
+    case 'running':
+      statusIcon = '●';
+      statusColor = codes.green;
+      break;
+    case 'completed':
+      statusIcon = '✓';
+      statusColor = codes.green;
+      break;
+    case 'failed':
+      statusIcon = '✗';
+      statusColor = codes.red;
+      break;
+    case 'queued':
+      statusIcon = '○';
+      statusColor = codes.yellow;
+      break;
+  }
+
+  if (colorsEnabled()) {
+    return `  ${statusColor}${statusIcon}${codes.reset} ${num} ${summary}`;
+  }
+  return `  ${statusIcon} ${num} ${summary}`;
+}
+
+/**
+ * Format the full UI screen.
+ *
+ * @param {Object|null} status - Daemon status object
+ * @returns {string} Formatted screen content
+ */
+function formatUI(status) {
+  const lines = [];
+
+  // Header
+  lines.push('');
+  if (colorsEnabled()) {
+    lines.push(`${codes.bold}Push Daemon Monitor${codes.reset}`);
+  } else {
+    lines.push('Push Daemon Monitor');
+  }
+  lines.push('─'.repeat(50));
+
+  if (!status) {
+    lines.push('');
+    lines.push('  Daemon not running or status unavailable.');
+    lines.push('  Run "push-todo" to start the daemon.');
+    lines.push('');
+    lines.push('─'.repeat(50));
+    lines.push('Press q to quit');
+    return lines.join('\n');
+  }
+
+  // Daemon info
+  lines.push('');
+  const daemonStatus = status.running ? 'Running' : 'Stopped';
+  const daemonColor = status.running ? codes.green : codes.red;
+
+  if (colorsEnabled()) {
+    lines.push(`  Status: ${daemonColor}${daemonStatus}${codes.reset}`);
+  } else {
+    lines.push(`  Status: ${daemonStatus}`);
+  }
+
+  if (status.pid) {
+    lines.push(`  PID: ${status.pid}`);
+  }
+
+  if (status.uptime) {
+    lines.push(`  Uptime: ${formatDuration(status.uptime)}`);
+  }
+
+  // Running tasks
+  lines.push('');
+  lines.push('─'.repeat(50));
+
+  const runningTasks = status.runningTasks || [];
+  if (runningTasks.length > 0) {
+    if (colorsEnabled()) {
+      lines.push(`${codes.bold}Running Tasks (${runningTasks.length})${codes.reset}`);
+    } else {
+      lines.push(`Running Tasks (${runningTasks.length})`);
+    }
+    lines.push('');
+
+    for (const task of runningTasks) {
+      lines.push(formatTaskLine(task));
+
+      // Show progress if available
+      if (task.progress) {
+        const progressBar = renderProgressBar(task.progress, 30);
+        lines.push(`       ${progressBar}`);
+      }
+
+      // Show current step if available
+      if (task.currentStep) {
+        const step = truncate(task.currentStep, 40);
+        if (colorsEnabled()) {
+          lines.push(`       ${codes.dim}${step}${codes.reset}`);
+        } else {
+          lines.push(`       ${step}`);
+        }
+      }
+    }
+  } else {
+    if (colorsEnabled()) {
+      lines.push(`${codes.dim}No tasks currently running${codes.reset}`);
+    } else {
+      lines.push('No tasks currently running');
+    }
+  }
+
+  // Queued tasks
+  const queuedTasks = status.queuedTasks || [];
+  if (queuedTasks.length > 0) {
+    lines.push('');
+    lines.push('─'.repeat(50));
+    if (colorsEnabled()) {
+      lines.push(`${codes.bold}Queued (${queuedTasks.length})${codes.reset}`);
+    } else {
+      lines.push(`Queued (${queuedTasks.length})`);
+    }
+    lines.push('');
+
+    for (const task of queuedTasks.slice(0, 5)) {
+      lines.push(formatTaskLine(task));
+    }
+
+    if (queuedTasks.length > 5) {
+      lines.push(`  ... and ${queuedTasks.length - 5} more`);
+    }
+  }
+
+  // Completed today
+  const completedToday = status.completedToday || [];
+  if (completedToday.length > 0) {
+    lines.push('');
+    lines.push('─'.repeat(50));
+    if (colorsEnabled()) {
+      lines.push(`${codes.bold}Completed Today (${completedToday.length})${codes.reset}`);
+    } else {
+      lines.push(`Completed Today (${completedToday.length})`);
+    }
+    lines.push('');
+
+    for (const task of completedToday.slice(-3)) {
+      lines.push(formatTaskLine({ ...task, status: 'completed' }));
+    }
+
+    if (completedToday.length > 3) {
+      lines.push(`  ... and ${completedToday.length - 3} more`);
+    }
+  }
+
+  // Footer
+  lines.push('');
+  lines.push('─'.repeat(50));
+  lines.push('Press q to quit, r to refresh');
+
+  return lines.join('\n');
+}
+
+/**
+ * Render a progress bar.
+ *
+ * @param {number} progress - Progress 0-100
+ * @param {number} width - Bar width in characters
+ * @returns {string} Rendered progress bar
+ */
+function renderProgressBar(progress, width) {
+  const filled = Math.round((progress / 100) * width);
+  const empty = width - filled;
+
+  if (colorsEnabled()) {
+    return `${codes.green}${'█'.repeat(filled)}${codes.dim}${'░'.repeat(empty)}${codes.reset} ${progress}%`;
+  }
+  return `[${'#'.repeat(filled)}${'-'.repeat(empty)}] ${progress}%`;
+}
+
+/**
+ * Output status as JSON (for non-TTY).
+ */
+function outputJSON() {
+  const status = readStatus();
+  console.log(JSON.stringify(status, null, 2));
+}
+
+/**
+ * Output status as plain text (for non-TTY).
+ */
+function outputPlainText() {
+  const status = readStatus();
+
+  if (!status) {
+    console.log('Daemon not running');
+    return;
+  }
+
+  console.log(`Status: ${status.running ? 'Running' : 'Stopped'}`);
+
+  if (status.pid) {
+    console.log(`PID: ${status.pid}`);
+  }
+
+  const running = status.runningTasks || [];
+  console.log(`Running tasks: ${running.length}`);
+
+  for (const task of running) {
+    console.log(`  #${task.displayNumber}: ${task.summary || 'Unknown'}`);
+  }
+
+  const queued = status.queuedTasks || [];
+  console.log(`Queued tasks: ${queued.length}`);
+}
+
+/**
+ * Start the live watch UI.
+ *
+ * @param {Object} options - Watch options
+ * @param {boolean} options.json - Output JSON instead of TUI
+ */
+export function startWatch(options = {}) {
+  // JSON mode
+  if (options.json) {
+    outputJSON();
+    return;
+  }
+
+  // Non-TTY mode
+  if (!process.stdout.isTTY) {
+    outputPlainText();
+    return;
+  }
+
+  // Live TUI mode
+  let running = true;
+
+  // Hide cursor
+  process.stdout.write(codes.hideCursor);
+
+  // Render function
+  function render() {
+    const status = readStatus();
+    const output = formatUI(status);
+    process.stdout.write(codes.clearScreen + codes.cursorHome + output);
+  }
+
+  // Initial render
+  render();
+
+  // Set up refresh interval
+  const interval = setInterval(() => {
+    if (running) {
+      render();
+    }
+  }, REFRESH_INTERVAL);
+
+  // Set up keyboard handling
+  readline.emitKeypressEvents(process.stdin);
+
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+
+  // Cleanup function
+  function cleanup() {
+    running = false;
+    clearInterval(interval);
+
+    // Show cursor
+    process.stdout.write(codes.showCursor);
+
+    // Clear screen and show exit message
+    process.stdout.write(codes.clearScreen + codes.cursorHome);
+    console.log('Watch mode ended.');
+
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+
+    process.exit(0);
+  }
+
+  // Handle keyboard input
+  process.stdin.on('keypress', (str, key) => {
+    if (key.name === 'q' || (key.ctrl && key.name === 'c')) {
+      cleanup();
+    } else if (key.name === 'r') {
+      render();
+    }
+  });
+
+  // Handle process signals
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+}

package/natives/KeychainHelper.swift

@@ -0,0 +1,134 @@
+#!/usr/bin/env swift
+/**
+ * Push Keychain Helper
+ *
+ * Retrieves the E2EE encryption key from iCloud Keychain.
+ * Used by the push-todo CLI for decrypting end-to-end encrypted tasks.
+ *
+ * Exit codes:
+ *   0 - Success (key printed to stdout as base64)
+ *   1 - Key not found in Keychain
+ *   2 - iCloud Keychain not available
+ *   3 - Other error
+ *
+ * Build:
+ *   swiftc -O KeychainHelper.swift -o push-keychain-helper
+ */
+
+import Foundation
+import Security
+
+/// Keychain service and account identifiers
+/// Must match the iOS app's keychain storage
+let keychainService = "ai.massless.push.e2ee"
+let keychainAccount = "encryption-key"
+
+/// Query the keychain for the E2EE encryption key
+func getEncryptionKey() -> (Data?, OSStatus) {
+    let query: [String: Any] = [
+        kSecClass as String: kSecClassGenericPassword,
+        kSecAttrService as String: keychainService,
+        kSecAttrAccount as String: keychainAccount,
+        kSecAttrSynchronizable as String: kCFBooleanTrue!,  // iCloud Keychain
+        kSecReturnData as String: kCFBooleanTrue!,
+        kSecMatchLimit as String: kSecMatchLimitOne
+    ]
+
+    var result: AnyObject?
+    let status = SecItemCopyMatching(query as CFDictionary, &result)
+
+    if status == errSecSuccess, let data = result as? Data {
+        return (data, status)
+    }
+
+    return (nil, status)
+}
+
+/// Check if iCloud Keychain is available
+func isICloudKeychainAvailable() -> Bool {
+    // Try to query for any iCloud synced item
+    let query: [String: Any] = [
+        kSecClass as String: kSecClassGenericPassword,
+        kSecAttrSynchronizable as String: kCFBooleanTrue!,
+        kSecMatchLimit as String: kSecMatchLimitOne,
+        kSecReturnAttributes as String: kCFBooleanTrue!
+    ]
+
+    var result: AnyObject?
+    let status = SecItemCopyMatching(query as CFDictionary, &result)
+
+    // If we get errSecItemNotFound, iCloud Keychain is available but empty
+    // If we get errSecSuccess, iCloud Keychain is available with items
+    // Other errors may indicate iCloud Keychain is not available
+    return status == errSecSuccess || status == errSecItemNotFound
+}
+
+/// Main entry point
+func main() -> Int32 {
+    // Handle --check flag
+    if CommandLine.arguments.contains("--check") {
+        if isICloudKeychainAvailable() {
+            print("iCloud Keychain available")
+            return 0
+        } else {
+            fputs("iCloud Keychain not available\n", stderr)
+            return 2
+        }
+    }
+
+    // Handle --help flag
+    if CommandLine.arguments.contains("--help") || CommandLine.arguments.contains("-h") {
+        print("""
+        Usage: push-keychain-helper [options]
+
+        Options:
+          --check    Check if iCloud Keychain is available
+          --help     Show this help
+
+        Without options, retrieves and prints the E2EE key as base64.
+
+        Exit codes:
+          0 - Success
+          1 - Key not found
+          2 - iCloud Keychain not available
+          3 - Other error
+        """)
+        return 0
+    }
+
+    // Check iCloud Keychain availability first
+    if !isICloudKeychainAvailable() {
+        fputs("Error: iCloud Keychain not available\n", stderr)
+        return 2
+    }
+
+    // Get the encryption key
+    let (keyData, status) = getEncryptionKey()
+
+    switch status {
+    case errSecSuccess:
+        if let data = keyData {
+            // Output as base64
+            print(data.base64EncodedString())
+            return 0
+        } else {
+            fputs("Error: Key data is nil\n", stderr)
+            return 3
+        }
+
+    case errSecItemNotFound:
+        fputs("Error: Encryption key not found in Keychain\n", stderr)
+        fputs("Make sure E2EE is enabled in the Push iOS app\n", stderr)
+        return 1
+
+    case errSecAuthFailed:
+        fputs("Error: Keychain authentication failed\n", stderr)
+        return 3
+
+    default:
+        fputs("Error: Keychain error (status: \(status))\n", stderr)
+        return 3
+    }
+}
+
+exit(main())

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@masslessai/push-todo",
+  "version": "3.0.0",
+  "description": "Voice tasks from Push iOS app for Claude Code",
+  "type": "module",
+  "bin": {
+    "push-todo": "./bin/push-todo.js"
+  },
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./fetch": "./lib/fetch.js",
+    "./connect": "./lib/connect.js",
+    "./config": "./lib/config.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "hooks/",
+    "commands/",
+    "natives/",
+    "scripts/",
+    ".claude-plugin/",
+    "SKILL.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "test": "node --test test/",
+    "start": "node bin/push-todo.js"
+  },
+  "keywords": [
+    "claude-code",
+    "claude-code-plugin",
+    "push",
+    "voice",
+    "todo",
+    "ios",
+    "cli"
+  ],
+  "author": "MasslessAI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MasslessAI/push-todo-cli"
+  },
+  "homepage": "https://pushto.do",
+  "bugs": {
+    "url": "https://github.com/MasslessAI/push-todo-cli/issues"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+/**
+ * Post-install script for Push CLI.
+ *
+ * Downloads the native keychain helper binary for macOS.
+ */
+
+import { createWriteStream, existsSync, mkdirSync, unlinkSync, readFileSync } from 'fs';
+import { chmod, stat } from 'fs/promises';
+import { pipeline } from 'stream/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir, platform, arch } from 'os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const BINARY_NAME = 'push-keychain-helper';
+const BINARY_DIR = join(__dirname, '../bin');
+const BINARY_PATH = join(BINARY_DIR, BINARY_NAME);
+
+// GitHub release URL pattern
+const RELEASE_VERSION = '3.0.0';
+const BINARY_URL = `https://github.com/MasslessAI/push-todo-cli/releases/download/v${RELEASE_VERSION}/${BINARY_NAME}-darwin-arm64`;
+const BINARY_URL_X64 = `https://github.com/MasslessAI/push-todo-cli/releases/download/v${RELEASE_VERSION}/${BINARY_NAME}-darwin-x64`;
+
+/**
+ * Migrate from old Python installation if present.
+ */
+function migrateFromPython() {
+  const oldPath = join(homedir(), '.claude', 'skills', 'push-todo');
+
+  if (existsSync(oldPath)) {
+    console.log('[push-todo] Detected previous Python installation.');
+    console.log(`[push-todo] Config preserved at ~/.config/push/`);
+    console.log(`[push-todo] Old files can be removed: rm -rf ${oldPath}`);
+    console.log('');
+  }
+}
+
+/**
+ * Download a file from URL to destination.
+ *
+ * @param {string} url - Source URL
+ * @param {string} dest - Destination path
+ * @returns {Promise<boolean>} True if successful
+ */
+async function downloadFile(url, dest) {
+  try {
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(60000) // 60 second timeout
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    // Ensure directory exists
+    mkdirSync(dirname(dest), { recursive: true });
+
+    // Remove existing file if present
+    if (existsSync(dest)) {
+      unlinkSync(dest);
+    }
+
+    // Write to file
+    const fileStream = createWriteStream(dest);
+    await pipeline(response.body, fileStream);
+
+    // Make executable
+    await chmod(dest, 0o755);
+
+    return true;
+  } catch (error) {
+    console.error(`[push-todo] Download failed: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Main post-install routine.
+ */
+async function main() {
+  console.log('[push-todo] Running post-install...');
+
+  // Check for migration
+  migrateFromPython();
+
+  // Check platform
+  if (platform() !== 'darwin') {
+    console.log('[push-todo] Skipping native binary (macOS only)');
+    console.log('[push-todo] E2EE features will not be available.');
+    console.log('[push-todo] Installation complete.');
+    return;
+  }
+
+  // Check if binary already exists and is valid
+  if (existsSync(BINARY_PATH)) {
+    try {
+      const stats = await stat(BINARY_PATH);
+      if (stats.size > 0) {
+        console.log('[push-todo] Native binary already installed.');
+        console.log('[push-todo] Installation complete.');
+        return;
+      }
+    } catch {
+      // Continue to download
+    }
+  }
+
+  // Determine architecture
+  const archType = arch();
+  const url = archType === 'arm64' ? BINARY_URL : BINARY_URL_X64;
+
+  console.log(`[push-todo] Downloading native binary for ${archType}...`);
+
+  const success = await downloadFile(url, BINARY_PATH);
+
+  if (success) {
+    console.log('[push-todo] Native binary installed successfully.');
+    console.log('[push-todo] E2EE decryption is now available.');
+  } else {
+    console.log('[push-todo] Native binary download failed.');
+    console.log('[push-todo] E2EE features will not be available.');
+    console.log('[push-todo] You can manually download from:');
+    console.log(`[push-todo]   ${url}`);
+  }
+
+  console.log('[push-todo] Installation complete.');
+}
+
+main().catch(error => {
+  console.error(`[push-todo] Post-install error: ${error.message}`);
+  // Don't fail the install - E2EE is optional
+  process.exit(0);
+});