@masslessai/push-todo 4.1.5 → 4.1.6

package/lib/agent-versions.js

@@ -1,8 +1,9 @@
 /**
- * Agent version detection and tracking for Push daemon.
+ * Agent version detection, tracking, and auto-update for Push daemon.
  *
  * Detects installed versions of Claude Code, OpenAI Codex, and OpenClaw CLIs.
  * Reports version parity with the push-todo CLI and flags outdated agents.
+ * Can auto-update agents via npm when enabled.
  *
  * Pattern: follows heartbeat.js — pure functions, internally throttled, non-fatal.
  */
@@ -11,25 +12,33 @@ import { execFileSync } from 'child_process';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
+import { compareSemver } from './self-update.js';
 
 const PUSH_DIR = join(homedir(), '.push');
 const VERSIONS_CACHE_FILE = join(PUSH_DIR, 'agent_versions.json');
+const LAST_AGENT_UPDATE_FILE = join(PUSH_DIR, 'last_agent_update_check');
 const CHECK_INTERVAL = 3600000; // 1 hour
+const AGENT_UPDATE_CHECK_INTERVAL = 3600000; // 1 hour
+const AGENT_VERSION_AGE_GATE = 3600000; // 1 hour — only install versions >1hr old
 
 // ==================== Agent Definitions ====================
 
 /**
- * Agent CLI definitions: command name, version flag, and how to parse output.
+ * Agent CLI definitions: command name, version flag, npm package, and how to parse output.
  *
  * Each agent has:
  * - cmd: the CLI binary name
  * - versionArgs: args to get version string
+ * - npmPackage: the npm package name for install/update
  * - parseVersion: extracts semver from command output
+ * - minVersion: minimum version required for push-todo compatibility (null = no minimum)
  */
 const AGENTS = {
   'claude-code': {
     cmd: 'claude',
     versionArgs: ['--version'],
+    npmPackage: '@anthropic-ai/claude-code',
+    minVersion: '2.0.0', // --worktree support
     parseVersion(output) {
       // "claude v2.1.41" or just "2.1.41"
       const match = output.match(/(\d+\.\d+\.\d+)/);
@@ -39,6 +48,8 @@ const AGENTS = {
   'openai-codex': {
     cmd: 'codex',
     versionArgs: ['--version'],
+    npmPackage: '@openai/codex',
+    minVersion: null,
     parseVersion(output) {
       const match = output.match(/(\d+\.\d+\.\d+)/);
       return match ? match[1] : null;
@@ -47,6 +58,8 @@ const AGENTS = {
   'openclaw': {
     cmd: 'openclaw',
     versionArgs: ['--version'],
+    npmPackage: 'openclaw',
+    minVersion: null,
     parseVersion(output) {
       const match = output.match(/(\d+\.\d+\.\d+)/);
       return match ? match[1] : null;
@@ -202,3 +215,147 @@ export function formatAgentVersionSummary(versions) {
 export function getKnownAgentTypes() {
   return Object.keys(AGENTS);
 }
+
+// ==================== Agent Update ====================
+
+/**
+ * Fetch latest version info for an agent from npm.
+ *
+ * @param {string} agentType
+ * @returns {{ version: string, publishedAt: string|null }|null}
+ */
+function fetchLatestAgentVersion(agentType) {
+  const agent = AGENTS[agentType];
+  if (!agent?.npmPackage) return null;
+
+  try {
+    const result = execFileSync('npm', ['view', agent.npmPackage, '--json'], {
+      timeout: 15000,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const data = JSON.parse(result);
+    const latest = data['dist-tags']?.latest || data.version;
+    return {
+      version: latest,
+      publishedAt: data.time?.[latest] || null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if an agent has an update available.
+ *
+ * @param {string} agentType
+ * @returns {{ available: boolean, current: string|null, latest: string|null, reason: string }}
+ */
+export function checkForAgentUpdate(agentType) {
+  const currentInfo = detectAgentVersion(agentType);
+  if (!currentInfo.installed || !currentInfo.version) {
+    return { available: false, current: null, latest: null, reason: 'not_installed' };
+  }
+
+  const latestInfo = fetchLatestAgentVersion(agentType);
+  if (!latestInfo) {
+    return { available: false, current: currentInfo.version, latest: null, reason: 'registry_unreachable' };
+  }
+
+  if (compareSemver(currentInfo.version, latestInfo.version) >= 0) {
+    return { available: false, current: currentInfo.version, latest: latestInfo.version, reason: 'up_to_date' };
+  }
+
+  // Safety: only update to versions published >1 hour ago
+  if (latestInfo.publishedAt) {
+    const publishedAge = Date.now() - new Date(latestInfo.publishedAt).getTime();
+    if (publishedAge < AGENT_VERSION_AGE_GATE) {
+      return { available: false, current: currentInfo.version, latest: latestInfo.version, reason: 'too_recent' };
+    }
+  }
+
+  return { available: true, current: currentInfo.version, latest: latestInfo.version, reason: 'update_available' };
+}
+
+/**
+ * Install a specific version of an agent CLI globally.
+ *
+ * @param {string} agentType
+ * @param {string} targetVersion
+ * @returns {boolean} true if update succeeded
+ */
+export function performAgentUpdate(agentType, targetVersion) {
+  const agent = AGENTS[agentType];
+  if (!agent?.npmPackage) return false;
+
+  try {
+    execFileSync('npm', ['install', '-g', `${agent.npmPackage}@${targetVersion}`], {
+      timeout: 120000,
+      stdio: 'pipe',
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check all installed agents for updates (throttled).
+ * Returns update results or null if throttled.
+ *
+ * @param {{ force?: boolean }} options
+ * @returns {Object.<string, { available: boolean, current: string|null, latest: string|null, reason: string }>|null}
+ */
+export function checkAllAgentUpdates({ force = false } = {}) {
+  // Throttle check
+  if (!force && existsSync(LAST_AGENT_UPDATE_FILE)) {
+    try {
+      const lastCheck = parseInt(readFileSync(LAST_AGENT_UPDATE_FILE, 'utf8').trim(), 10);
+      if (Date.now() - lastCheck < AGENT_UPDATE_CHECK_INTERVAL) {
+        return null;
+      }
+    } catch {}
+  }
+
+  // Record check time
+  try {
+    mkdirSync(PUSH_DIR, { recursive: true });
+    writeFileSync(LAST_AGENT_UPDATE_FILE, String(Date.now()));
+  } catch {}
+
+  const results = {};
+  for (const agentType of Object.keys(AGENTS)) {
+    const info = detectAgentVersion(agentType);
+    if (info.installed) {
+      results[agentType] = checkForAgentUpdate(agentType);
+    }
+  }
+  return results;
+}
+
+// ==================== Version Parity ====================
+
+/**
+ * Check version parity between installed agents and push-todo requirements.
+ * Returns warnings for agents that are below minimum required versions.
+ *
+ * @returns {{ agentType: string, installed: string, required: string }[]}
+ */
+export function checkVersionParity() {
+  const warnings = [];
+  for (const [agentType, agent] of Object.entries(AGENTS)) {
+    if (!agent.minVersion) continue;
+
+    const info = detectAgentVersion(agentType);
+    if (info.installed && info.version) {
+      if (compareSemver(info.version, agent.minVersion) < 0) {
+        warnings.push({
+          agentType,
+          installed: info.version,
+          required: agent.minVersion,
+        });
+      }
+    }
+  }
+  return warnings;
+}

package/lib/config.js

@@ -213,6 +213,27 @@ export function setAutoUpdateEnabled(enabled) {
   return setConfigValue('AUTO_UPDATE', enabled ? 'true' : 'false');
 }
 
+/**
+ * Check if auto-update-agents is enabled for daemon agent CLI updates.
+ * Default: false (agent updates are opt-in since they're third-party CLIs)
+ *
+ * @returns {boolean}
+ */
+export function getAutoUpdateAgentsEnabled() {
+  const value = getConfigValue('AUTO_UPDATE_AGENTS', 'false');
+  return value.toLowerCase() === 'true' || value === '1' || value.toLowerCase() === 'yes';
+}
+
+/**
+ * Set auto-update-agents setting.
+ *
+ * @param {boolean} enabled
+ * @returns {boolean} True if successful
+ */
+export function setAutoUpdateAgentsEnabled(enabled) {
+  return setConfigValue('AUTO_UPDATE_AGENTS', enabled ? 'true' : 'false');
+}
+
 /**
  * Get the maximum batch size for queuing tasks.
  * Default: 5
@@ -292,6 +313,7 @@ export function showSettings() {
   const autoMerge = getAutoMergeEnabled();
   const autoComplete = getAutoCompleteEnabled();
   const autoUpdate = getAutoUpdateEnabled();
+  const autoUpdateAgents = getAutoUpdateAgentsEnabled();
   const batchSize = getMaxBatchSize();
 
   console.log(`  auto-commit:    ${autoCommit ? 'ON' : 'OFF'}`);
@@ -304,7 +326,10 @@ export function showSettings() {
   console.log('                  Mark task completed after successful merge');
   console.log();
   console.log(`  auto-update:    ${autoUpdate ? 'ON' : 'OFF'}`);
-  console.log('                  Daemon auto-updates from npm when idle');
+  console.log('                  Daemon auto-updates push-todo from npm when idle');
+  console.log();
+  console.log(`  auto-update-agents: ${autoUpdateAgents ? 'ON' : 'OFF'}`);
+  console.log('                  Daemon auto-updates agent CLIs (Claude, Codex, OpenClaw)');
   console.log();
   console.log(`  batch-size:     ${batchSize}`);
   console.log('                  Max tasks for batch queue (1-20)');
@@ -387,6 +412,22 @@ export function toggleSetting(settingName) {
     return false;
   }
 
+  if (normalized === 'auto-update-agents') {
+    const current = getAutoUpdateAgentsEnabled();
+    const newValue = !current;
+    if (setAutoUpdateAgentsEnabled(newValue)) {
+      console.log(`Auto-update-agents is now ${newValue ? 'ON' : 'OFF'}`);
+      if (newValue) {
+        console.log('Daemon will auto-update agent CLIs (Claude Code, Codex, OpenClaw) when idle.');
+      } else {
+        console.log('Agent CLIs will NOT be auto-updated. Use "push-todo update" for manual updates.');
+      }
+      return true;
+    }
+    console.error('Failed to update setting');
+    return false;
+  }
+
   if (normalized === 'batch-size') {
     const batchSize = getMaxBatchSize();
     console.log(`Current batch size: ${batchSize}`);
@@ -395,7 +436,7 @@ export function toggleSetting(settingName) {
   }
 
   console.error(`Unknown setting: ${settingName}`);
-  console.error('Available settings: auto-commit, auto-merge, auto-complete, auto-update, batch-size');
+  console.error('Available settings: auto-commit, auto-merge, auto-complete, auto-update, auto-update-agents, batch-size');
   return false;
 }
 

package/lib/daemon.js

@@ -25,7 +25,7 @@ import { getProjectContext, buildSmartPrompt, invalidateCache } from './context-
 import { sendMacNotification } from './utils/notify.js';
 import { checkAndRunDueJobs } from './cron.js';
 import { runHeartbeatChecks } from './heartbeat.js';
-import { getAgentVersions, formatAgentVersionSummary } from './agent-versions.js';
+import { getAgentVersions, formatAgentVersionSummary, checkAllAgentUpdates, performAgentUpdate, checkVersionParity } from './agent-versions.js';
 import { checkAllProjectsFreshness } from './project-freshness.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -282,6 +282,11 @@ function getAutoUpdateEnabled() {
   return v.toLowerCase() === 'true' || v === '1' || v.toLowerCase() === 'yes';
 }
 
+function getAutoUpdateAgentsEnabled() {
+  const v = getConfigValueFromFile('AUTO_UPDATE_AGENTS', 'false');
+  return v.toLowerCase() === 'true' || v === '1' || v.toLowerCase() === 'yes';
+}
+
 // ==================== Capabilities Detection ====================
 
 let cachedCapabilities = null;
@@ -2355,6 +2360,55 @@ function checkAndApplyUpdate() {
   }
 }
 
+// ==================== Agent Auto-Update ====================
+
+let pendingAgentUpdates = null; // { agentType: targetVersion, ... }
+
+function checkAndApplyAgentUpdates() {
+  // Check for updates (throttled internally to once per hour)
+  if (!pendingAgentUpdates) {
+    const results = checkAllAgentUpdates();
+    if (!results) return; // throttled
+
+    const available = {};
+    for (const [agentType, info] of Object.entries(results)) {
+      if (info.available) {
+        available[agentType] = info.latest;
+        log(`Agent update available: ${agentType} v${info.current} -> v${info.latest}`);
+      }
+    }
+    if (Object.keys(available).length > 0) {
+      pendingAgentUpdates = available;
+    }
+  }
+
+  // Only apply when no tasks are running
+  if (pendingAgentUpdates && runningTasks.size === 0) {
+    for (const [agentType, targetVersion] of Object.entries(pendingAgentUpdates)) {
+      log(`Updating ${agentType} to v${targetVersion}...`);
+      const success = performAgentUpdate(agentType, targetVersion);
+      if (success) {
+        log(`${agentType} updated to v${targetVersion}`);
+        sendMacNotification(
+          'Push: Agent Updated',
+          `${agentType} updated to v${targetVersion}`,
+          'Glass'
+        );
+      } else {
+        logError(`${agentType} update to v${targetVersion} failed`);
+      }
+    }
+    pendingAgentUpdates = null;
+  }
+}
+
+function logVersionParityWarnings() {
+  const warnings = checkVersionParity();
+  for (const w of warnings) {
+    log(`WARNING: ${w.agentType} v${w.installed} is below minimum v${w.required} — some features may not work`);
+  }
+}
+
 // ==================== Main Loop ====================
 
 async function pollAndExecute() {
@@ -2457,10 +2511,12 @@ async function mainLoop() {
   log(`Max concurrent tasks: ${MAX_CONCURRENT_TASKS}`);
   log(`E2EE: ${e2eeAvailable ? 'Available' : 'Not available'}`);
   log(`Auto-update: ${getAutoUpdateEnabled() ? 'Enabled' : 'Disabled'}`);
+  log(`Auto-update-agents: ${getAutoUpdateAgentsEnabled() ? 'Enabled' : 'Disabled'}`);
   const caps = getCapabilities();
   log(`Capabilities: gh=${caps.gh_cli}, auto-merge=${caps.auto_merge}, auto-complete=${caps.auto_complete}`);
   const agentVersions = getAgentVersions({ force: true });
   log(`Agent versions: ${formatAgentVersionSummary(agentVersions)}`);
+  logVersionParityWarnings();
   log(`Log file: ${LOG_FILE}`);
 
   // Show registered projects
@@ -2559,6 +2615,15 @@ async function mainLoop() {
       if (getAutoUpdateEnabled()) {
         checkAndApplyUpdate();
       }
+
+      // Agent CLI auto-update (throttled to once per hour, only applies when idle)
+      if (getAutoUpdateAgentsEnabled()) {
+        try {
+          checkAndApplyAgentUpdates();
+        } catch (error) {
+          logError(`Agent auto-update error: ${error.message}`);
+        }
+      }
     } catch (error) {
       logError(`Poll error: ${error.message}`);
     }

package/lib/self-update.js

@@ -17,12 +17,16 @@ const LAST_UPDATE_CHECK_FILE = join(PUSH_DIR, 'last_update_check');
 const UPDATE_CHECK_INTERVAL = 3600000; // 1 hour
 
 /**
- * Compare semver strings.
+ * Compare semver strings (strips pre-release/build metadata before comparing).
+ * Handles formats like "2.1.41", "2026.2.22-2", "1.0.0+build.123".
  * @returns -1 if a < b, 0 if equal, 1 if a > b
  */
 export function compareSemver(a, b) {
-  const pa = a.split('.').map(Number);
-  const pb = b.split('.').map(Number);
+  // Strip pre-release (-beta.1) and build metadata (+build.123)
+  const cleanA = a.split('-')[0].split('+')[0];
+  const cleanB = b.split('-')[0].split('+')[0];
+  const pa = cleanA.split('.').map(Number);
+  const pb = cleanB.split('.').map(Number);
   for (let i = 0; i < 3; i++) {
     if ((pa[i] || 0) < (pb[i] || 0)) return -1;
     if ((pa[i] || 0) > (pb[i] || 0)) return 1;

package/lib/update.js

@@ -1,25 +1,30 @@
 /**
  * Manual update orchestrator for Push CLI.
  *
- * `push-todo update` performs three actions:
+ * `push-todo update` performs four actions:
  * 1. Self-update: check and install latest push-todo from npm
- * 2. Agent versions: detect and display installed agent CLI versions
- * 3. Project freshness: fetch and rebase registered projects that are behind
+ * 2. Agent CLIs: detect versions, check for updates, and install if available
+ * 3. Version parity: warn if agents are below minimum required versions
+ * 4. Project freshness: fetch and rebase registered projects that are behind
  *
  * Separation of concerns:
- * - Daemon: runs all three checks periodically (hourly, throttled, non-interactive)
+ * - Daemon: runs all checks periodically (hourly, throttled, non-interactive)
+ *   - Self-update: always (gated by auto-update setting)
+ *   - Agent updates: opt-in (gated by auto-update-agents setting, default OFF)
+ *   - Project freshness: always (gated by auto-update setting)
  * - This module: runs on explicit user request (immediate, verbose, interactive)
+ *   - Always checks and updates everything, no settings gate
  */
 
 import { readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 
-import { checkForUpdate, performUpdate, compareSemver } from './self-update.js';
-import { getAgentVersions, getKnownAgentTypes } from './agent-versions.js';
+import { checkForUpdate, performUpdate } from './self-update.js';
+import { getAgentVersions, getKnownAgentTypes, checkForAgentUpdate, performAgentUpdate, checkVersionParity } from './agent-versions.js';
 import { checkProjectFreshness } from './project-freshness.js';
 import { getRegistry } from './project-registry.js';
-import { bold, green, yellow, red, cyan, dim } from './utils/colors.js';
+import { bold, green, yellow, red, dim } from './utils/colors.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -76,7 +81,7 @@ export async function runManualUpdate(values) {
   }
   console.log();
 
-  // ── 2. Agent versions ──────────────────────────────────
+  // ── 2. Agent CLIs ──────────────────────────────────────
   console.log(bold('  Agent CLIs'));
 
   const agentVersions = getAgentVersions({ force: true });
@@ -84,12 +89,41 @@ export async function runManualUpdate(values) {
     const info = agentVersions[type];
     const label = AGENT_LABELS[type] || type;
 
-    if (info.installed && info.version) {
-      console.log(`  ${label}: ${green('v' + info.version)}`);
-    } else if (info.installed) {
+    if (!info.installed) {
+      console.log(`  ${label}: ${dim('not installed')}`);
+      continue;
+    }
+
+    if (!info.version) {
       console.log(`  ${label}: ${yellow('installed')} ${dim('(version unknown)')}`);
+      continue;
+    }
+
+    // Check for update
+    const updateInfo = checkForAgentUpdate(type);
+    if (updateInfo.available) {
+      console.log(`  ${label}: v${info.version} -> ${green('v' + updateInfo.latest)} available`);
+      console.log(`  Updating ${label} to v${updateInfo.latest}...`);
+      const success = performAgentUpdate(type, updateInfo.latest);
+      if (success) {
+        console.log(`  ${green('Updated successfully')}`);
+      } else {
+        console.log(`  ${red('Update failed')}`);
+      }
+    } else if (updateInfo.reason === 'too_recent') {
+      console.log(`  ${label}: ${green('v' + info.version)} ${dim(`(v${updateInfo.latest} published <1hr ago)`)}`);
     } else {
-      console.log(`  ${label}: ${dim('not installed')}`);
+      console.log(`  ${label}: ${green('v' + info.version)}`);
+    }
+  }
+
+  // Version parity warnings
+  const parityWarnings = checkVersionParity();
+  if (parityWarnings.length > 0) {
+    console.log();
+    for (const w of parityWarnings) {
+      const label = AGENT_LABELS[w.agentType] || w.agentType;
+      console.log(`  ${yellow('Warning')}: ${label} v${w.installed} is below minimum v${w.required}`);
     }
   }
   console.log();

package/package.json

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