@masslessai/push-todo 4.2.9 → 4.4.0

package/lib/cron.js

@@ -1,51 +1,13 @@
 /**
- * Cron job scheduler for Push daemon.
+ * Schedule engine for Push daemon.
  *
- * Stores recurring/one-shot jobs in ~/.push/cron/jobs.json.
- * Called from daemon main loop on each poll cycle.
+ * Pure scheduling logic (interval parsing, cron expressions, next-run computation)
+ * plus the remote schedule checker that polls Supabase.
  *
  * No npm dependencies — includes minimal cron expression parser.
- * Architecture: docs/20260214_push_daemon_evolution_complete_architecture.md §23
- * Pattern: Follow self-update.js — pure functions, called from daemon.js.
+ * Architecture: docs/20260301_system_architecture_complete_reference.md
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import { randomUUID } from 'crypto';
-import { sendMacNotification } from './utils/notify.js';
-
-const CRON_DIR = join(homedir(), '.push', 'cron');
-const JOBS_FILE = join(CRON_DIR, 'jobs.json');
-
-// ==================== Storage ====================
-
-function ensureCronDir() {
-  mkdirSync(CRON_DIR, { recursive: true });
-}
-
-/**
- * Load all cron jobs from disk.
- * @returns {Array} Job objects
- */
-export function loadJobs() {
-  if (!existsSync(JOBS_FILE)) return [];
-  try {
-    return JSON.parse(readFileSync(JOBS_FILE, 'utf8'));
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Save all cron jobs to disk.
- * @param {Array} jobs
- */
-export function saveJobs(jobs) {
-  ensureCronDir();
-  writeFileSync(JOBS_FILE, JSON.stringify(jobs, null, 2) + '\n');
-}
-
 // ==================== Interval Parsing ====================
 
 /**
@@ -225,214 +187,135 @@ export function computeNextRun(schedule, fromDate = new Date()) {
   }
 }
 
-// ==================== Job Management ====================
+// ==================== Remote Schedules (Supabase) ====================
 
 /**
- * Add a new cron job.
+ * Check for and run any due remote schedules from Supabase.
+ * Called from daemon poll loop on every cycle.
  *
- * @param {Object} config
- * @param {string} config.name - Job name
- * @param {{ type: string, value: string }} config.schedule - Schedule definition
- * @param {{ type: string, content: string }} config.action - Action to perform
- * @returns {Object} Created job
+ * @param {Function} [logFn] - Optional log function
+ * @param {Object} [context] - Injected dependencies from daemon
+ * @param {Function} [context.apiRequest] - API request function
  */
-export function addJob(config) {
-  const { name, schedule, action } = config;
+export async function checkAndRunRemoteSchedules(logFn, context = {}) {
+  const log = logFn || (() => {});
 
-  if (!name) throw new Error('Job name is required');
-  if (!schedule || !schedule.type || !schedule.value) throw new Error('Schedule is required');
-  if (!action || !action.type) throw new Error('Action is required');
+  if (!context.apiRequest) return;
 
-  // Validate schedule by computing next run
-  const nextRunAt = computeNextRun(schedule);
-  if (!nextRunAt) {
-    throw new Error(`Schedule "${schedule.type}: ${schedule.value}" has no future run time`);
+  // 1. Fetch due schedules
+  let schedules;
+  try {
+    const response = await context.apiRequest('manage-schedules?due=true', {
+      method: 'GET',
+    });
+    if (!response.ok) {
+      log(`Remote schedules: fetch failed (HTTP ${response.status})`);
+      return;
+    }
+    const data = await response.json();
+    schedules = data.schedules || [];
+  } catch (error) {
+    log(`Remote schedules: fetch error: ${error.message}`);
+    return;
   }
 
-  const job = {
-    id: randomUUID(),
-    name,
-    schedule,
-    action,
-    enabled: true,
-    createdAt: new Date().toISOString(),
-    lastRunAt: null,
-    nextRunAt,
-  };
-
-  const jobs = loadJobs();
-  jobs.push(job);
-  saveJobs(jobs);
-
-  return job;
-}
+  if (schedules.length === 0) return;
 
-/**
- * Remove a cron job by ID or ID prefix.
- *
- * @param {string} idOrPrefix - Full UUID or prefix (min 4 chars)
- * @returns {boolean} True if found and removed
- */
-export function removeJob(idOrPrefix) {
-  const jobs = loadJobs();
-  const idx = jobs.findIndex(j =>
-    j.id === idOrPrefix || j.id.startsWith(idOrPrefix)
-  );
+  log(`Remote schedules: ${schedules.length} due`);
 
-  if (idx === -1) return false;
+  // 2. Fire each due schedule
+  for (const schedule of schedules) {
+    const expectedNextRunAt = schedule.next_run_at;
 
-  jobs.splice(idx, 1);
-  saveJobs(jobs);
-  return true;
-}
-
-/**
- * List all cron jobs.
- * @returns {Array} Job objects
- */
-export function listJobs() {
-  return loadJobs();
-}
-
-// ==================== Execution ====================
-
-/**
- * Execute a cron job action.
- *
- * @param {Object} job - Job object
- * @param {Function} [logFn] - Optional log function
- * @param {Object} [context] - Injected dependencies from daemon
- * @param {Function} [context.apiRequest] - API request function
- * @param {Function} [context.spawnHealthCheck] - Spawn a health check Claude session
- */
-async function executeAction(job, logFn, context = {}) {
-  const log = logFn || (() => {});
+    try {
+      if (schedule.action_type === 'create-todo') {
+        // Create a new todo
+        const payload = {
+          title: schedule.action_title || schedule.name,
+          normalizedContent: schedule.action_content || null,
+          isBacklog: false,
+          createdByClient: 'daemon-schedule',
+        };
+        if (schedule.git_remote) {
+          payload.gitRemote = schedule.git_remote;
+          payload.actionType = 'claude-code';
+        }
 
-  switch (job.action.type) {
-    case 'notify':
-      sendMacNotification('Push Cron', job.action.content || job.name);
-      log(`Cron "${job.name}": notification sent`);
-      break;
-
-    case 'create-todo':
-      if (context.apiRequest) {
-        try {
-          const response = await context.apiRequest('create-todo', {
-            method: 'POST',
-            body: JSON.stringify({
-              title: job.action.content || job.name,
-              normalizedContent: job.action.detail || null,
-              isBacklog: job.action.backlog || false,
-              createdByClient: 'daemon-cron',
-            }),
-          });
-          if (response.ok) {
-            const data = await response.json();
-            log(`Cron "${job.name}": created todo #${data.todo?.displayNumber || '?'}`);
-          } else {
-            log(`Cron "${job.name}": create-todo failed (HTTP ${response.status})`);
-            // Fall back to notification
-            sendMacNotification('Push: Scheduled Todo', job.action.content || job.name);
-          }
-        } catch (error) {
-          log(`Cron "${job.name}": create-todo error: ${error.message}`);
-          sendMacNotification('Push: Scheduled Todo', job.action.content || job.name);
+        const todoResponse = await context.apiRequest('create-todo', {
+          method: 'POST',
+          body: JSON.stringify(payload),
+        });
+        if (todoResponse.ok) {
+          const todoData = await todoResponse.json();
+          log(`Schedule "${schedule.name}": created todo #${todoData.todo?.displayNumber || '?'}`);
+        } else {
+          log(`Schedule "${schedule.name}": create-todo failed (HTTP ${todoResponse.status})`);
         }
-      } else {
-        sendMacNotification('Push: Scheduled Todo', job.action.content || job.name);
-        log(`Cron "${job.name}": todo reminder sent (notification, no API context)`);
-      }
-      break;
-
-    case 'queue-execution':
-      if (!job.action.todoId) {
-        log(`Cron "${job.name}": queue-execution requires todoId, skipping`);
-      } else if (context.apiRequest) {
-        try {
-          const response = await context.apiRequest('update-task-execution', {
+
+      } else if (schedule.action_type === 'queue-todo') {
+        // Re-queue an existing todo
+        if (!schedule.todo_id) {
+          log(`Schedule "${schedule.name}": queue-todo has no todo_id, disabling`);
+          await context.apiRequest('manage-schedules', {
             method: 'PATCH',
             body: JSON.stringify({
-              todoId: job.action.todoId,
-              status: 'queued',
+              id: schedule.id,
+              enabled: false,
+              lastRunAt: new Date().toISOString(),
+              nextRunAt: null,
             }),
           });
-          if (response.ok) {
-            log(`Cron "${job.name}": queued todo ${job.action.todoId} for execution`);
-          } else {
-            log(`Cron "${job.name}": queue-execution failed (HTTP ${response.status})`);
-          }
-        } catch (error) {
-          log(`Cron "${job.name}": queue-execution error: ${error.message}`);
+          continue;
         }
-      } else {
-        log(`Cron "${job.name}": queue-execution not available (no API context)`);
-      }
-      break;
-
-    case 'health-check':
-      if (context.spawnHealthCheck) {
-        try {
-          await context.spawnHealthCheck(job, log);
-        } catch (error) {
-          log(`Cron "${job.name}": health-check error: ${error.message}`);
+
+        const queueResponse = await context.apiRequest('update-task-execution', {
+          method: 'PATCH',
+          body: JSON.stringify({
+            todoId: schedule.todo_id,
+            status: 'queued',
+          }),
+        });
+        if (queueResponse.ok) {
+          log(`Schedule "${schedule.name}": queued todo ${schedule.todo_id}`);
+        } else {
+          log(`Schedule "${schedule.name}": queue-todo failed (HTTP ${queueResponse.status})`);
         }
-      } else {
-        log(`Cron "${job.name}": health-check not available (no daemon context)`);
       }
-      break;
-
-    default:
-      log(`Cron "${job.name}": unknown action type "${job.action.type}"`);
-  }
-}
-
-/**
- * Check for and run any due cron jobs.
- * Called from daemon poll loop on every cycle.
- *
- * @param {Function} [logFn] - Optional log function
- * @param {Object} [context] - Injected dependencies (apiRequest, spawnHealthCheck)
- */
-export async function checkAndRunDueJobs(logFn, context = {}) {
-  const jobs = loadJobs();
-  if (jobs.length === 0) return;
-
-  const now = new Date();
-  let modified = false;
-
-  for (const job of jobs) {
-    if (!job.enabled) continue;
-    if (!job.nextRunAt) continue;
-
-    const nextRun = new Date(job.nextRunAt);
-    if (nextRun > now) continue;
-
-    // Job is due — execute
-    try {
-      await executeAction(job, logFn, context);
     } catch (error) {
-      if (logFn) logFn(`Cron "${job.name}" execution failed: ${error.message}`);
+      log(`Schedule "${schedule.name}": execution error: ${error.message}`);
     }
 
-    // Update timing
-    job.lastRunAt = now.toISOString();
+    // 3. Advance next_run_at (with optimistic lock)
+    const now = new Date();
+    const scheduleConfig = { type: schedule.schedule_type, value: schedule.schedule_value };
 
-    if (job.schedule.type === 'at') {
+    let nextRunAt = null;
+    let enabled = true;
+
+    if (schedule.schedule_type === 'at') {
       // One-shot: disable after run
-      job.enabled = false;
-      job.nextRunAt = null;
+      enabled = false;
     } else {
       // Recurring: compute next run
-      job.nextRunAt = computeNextRun(job.schedule, now);
-      if (!job.nextRunAt) {
-        job.enabled = false; // No more future runs
+      nextRunAt = computeNextRun(scheduleConfig, now);
+      if (!nextRunAt) {
+        enabled = false;
       }
     }
 
-    modified = true;
-  }
-
-  if (modified) {
-    saveJobs(jobs);
+    try {
+      await context.apiRequest('manage-schedules', {
+        method: 'PATCH',
+        body: JSON.stringify({
+          id: schedule.id,
+          enabled,
+          lastRunAt: now.toISOString(),
+          nextRunAt,
+          expectedNextRunAt,
+        }),
+      });
+    } catch (error) {
+      log(`Schedule "${schedule.name}": failed to advance next_run_at: ${error.message}`);
+    }
   }
 }

package/lib/daemon.js

@@ -23,7 +23,7 @@ import { fileURLToPath } from 'url';
 import { checkForUpdate, performUpdate } from './self-update.js';
 import { getProjectContext, buildSmartPrompt, invalidateCache } from './context-engine.js';
 import { sendMacNotification } from './utils/notify.js';
-import { checkAndRunDueJobs } from './cron.js';
+import { checkAndRunRemoteSchedules } from './cron.js';
 import { runHeartbeatChecks } from './heartbeat.js';
 import { getAgentVersions, formatAgentVersionSummary, checkAllAgentUpdates, performAgentUpdate, checkVersionParity, ensureAgentReady } from './agent-versions.js';
 import { checkAllProjectsFreshness } from './project-freshness.js';
@@ -1693,14 +1693,22 @@ function respawnWithInjectedMessage(displayNumber) {
 
   const injectionPrompt = `IMPORTANT: The human sent you an urgent message while you were working:\n\n---\n${message}\n---\n\nPlease address this message and then continue with your task.`;
 
-  const allowedTools = [
+  // Reuse the same expanded tool list as executeTask
+  const baseTools = [
     'Read', 'Edit', 'Write', 'Glob', 'Grep',
     'Bash(git *)',
     'Bash(npm *)', 'Bash(npx *)', 'Bash(yarn *)',
     'Bash(python *)', 'Bash(python3 *)', 'Bash(pip *)', 'Bash(pip3 *)',
     'Bash(push-todo *)',
-    'Task'
-  ].join(',');
+    'Task',
+    'WebSearch', 'WebFetch',
+    'ToolSearch',
+  ];
+  const projectContext = projectPath ? getProjectContext(projectPath) : { skills: [], state: {} };
+  const skillTools = (projectContext.skills || [])
+    .flatMap(s => s.tools || [])
+    .filter(t => !baseTools.includes(t));
+  const allowedTools = [...baseTools, ...skillTools].join(',');
 
   // Generate new session ID for the respawned session
   const newSessionId = randomUUID();
@@ -2371,14 +2379,22 @@ async function executeTask(task) {
   // No duplicate status update needed here (was causing race conditions)
 
   // Build Claude command
-  const allowedTools = [
+  const baseTools = [
     'Read', 'Edit', 'Write', 'Glob', 'Grep',
     'Bash(git *)',
     'Bash(npm *)', 'Bash(npx *)', 'Bash(yarn *)',
     'Bash(python *)', 'Bash(python3 *)', 'Bash(pip *)', 'Bash(pip3 *)',
     'Bash(push-todo *)',
-    'Task'
-  ].join(',');
+    'Task',
+    'WebSearch', 'WebFetch',
+    'ToolSearch',
+  ];
+
+  // Merge tools declared by project skills (via `tools` frontmatter in SKILL.md)
+  const skillTools = (projectContext.skills || [])
+    .flatMap(s => s.tools || [])
+    .filter(t => !baseTools.includes(t));
+  const allowedTools = [...baseTools, ...skillTools].join(',');
 
   // For follow-ups: try --continue with previous session for full context.
   // Falls back to new session with prompt context if session is stale/unavailable.
@@ -3062,126 +3078,6 @@ function logVersionParityWarnings() {
 
 // ==================== Health Check (Phase 5) ====================
 
-/**
- * Spawn a health check Claude session for a project.
- * Called by the cron module when a health-check job fires.
- *
- * The session runs in the project directory with a special prompt that asks
- * Claude to review the codebase and suggest tasks. Results are created as
- * draft todos via the create-todo API.
- *
- * @param {Object} job - Cron job object
- * @param {Function} logFn - Log function
- */
-async function spawnHealthCheck(job, logFn) {
-  const projectPath = job.action.projectPath;
-  if (!projectPath || !existsSync(projectPath)) {
-    logFn(`Health check: project path not found: ${projectPath}`);
-    return;
-  }
-
-  // Don't run if task slots are full
-  if (runningTasks.size >= MAX_CONCURRENT_TASKS) {
-    logFn(`Health check: all ${MAX_CONCURRENT_TASKS} slots in use, deferring`);
-    return;
-  }
-
-  const scope = job.action.scope || 'general';
-  const customPrompt = job.action.prompt || '';
-
-  const healthPrompts = {
-    general: `Review this codebase briefly. Check for:
-1. Failing tests (run the test suite if one exists)
-2. Obvious bugs or issues in recently modified files (last 7 days)
-3. Outdated dependencies worth updating
-
-For each issue found, create a todo using: push-todo create "<clear description of the issue>"
-Only create todos for real, actionable issues — not style preferences or minor improvements.
-If everything looks good, just say "No issues found" and don't create any todos.`,
-    tests: `Run the test suite for this project. If any tests fail, create a todo for each failure:
-push-todo create "Fix failing test: <test name> - <brief reason>"
-If all tests pass, say "All tests pass" and don't create any todos.`,
-    dependencies: `Check for outdated dependencies in this project. Only flag dependencies with:
-- Known security vulnerabilities
-- Major version bumps (not minor/patch)
-For each, create a todo: push-todo create "Update <dep> from <old> to <new> (<reason>)"
-If dependencies are current, say "All dependencies up to date."`,
-  };
-
-  const prompt = customPrompt || healthPrompts[scope] || healthPrompts.general;
-
-  const allowedTools = [
-    'Read', 'Glob', 'Grep',
-    'Bash(git *)',
-    'Bash(npm *)', 'Bash(npx *)',
-    'Bash(python *)', 'Bash(python3 *)',
-    'Bash(push-todo create *)',
-  ].join(',');
-
-  const claudeArgs = [
-    '-p', prompt,
-    '--verbose',
-    '--allowedTools', allowedTools,
-    '--output-format', 'stream-json',
-    '--permission-mode', 'bypassPermissions',
-  ];
-
-  logFn(`Health check "${job.name}": spawning Claude in ${projectPath} (scope: ${scope})`);
-
-  try {
-    const child = spawn('claude', claudeArgs, {
-      cwd: projectPath,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      env: (() => {
-        const env = { ...process.env };
-        delete env.CLAUDECODE;
-        delete env.CLAUDE_CODE_ENTRYPOINT;
-        return env;
-      })(),
-      timeout: 300000, // 5 min max for health checks
-    });
-
-    // Simple output tracking — health checks are lightweight, no full task tracking
-    let output = '';
-    child.stdout.on('data', (data) => {
-      output += data.toString();
-    });
-
-    child.stderr.on('data', (data) => {
-      const errLine = data.toString().trim();
-      if (errLine) logFn(`Health check "${job.name}" stderr: ${errLine}`);
-    });
-
-    await new Promise((resolve) => {
-      child.on('close', (code) => {
-        if (code === 0) {
-          logFn(`Health check "${job.name}": completed successfully`);
-        } else {
-          logFn(`Health check "${job.name}": exited with code ${code}`);
-        }
-        resolve();
-      });
-      child.on('error', (err) => {
-        logFn(`Health check "${job.name}": spawn error: ${err.message}`);
-        resolve();
-      });
-    });
-
-    // Extract any text summary from stream-json output
-    const lines = output.split('\n').filter(l => l.trim());
-    for (const line of lines) {
-      try {
-        const event = JSON.parse(line);
-        if (event.type === 'result' && event.result) {
-          logFn(`Health check "${job.name}" result: ${event.result.slice(0, 200)}`);
-        }
-      } catch { /* ignore non-JSON lines */ }
-    }
-  } catch (error) {
-    logFn(`Health check "${job.name}": error: ${error.message}`);
-  }
-}
-
 // ==================== Main Loop ====================
 
 async function pollAndExecute() {
@@ -3352,11 +3248,11 @@ async function mainLoop() {
 
       await pollAndExecute();
 
-      // Cron jobs (check every poll cycle, execution throttled by nextRunAt)
+      // Remote schedules from Supabase
       try {
-        await checkAndRunDueJobs(log, { apiRequest, spawnHealthCheck });
+        await checkAndRunRemoteSchedules(log, { apiRequest });
       } catch (error) {
-        logError(`Cron check error: ${error.message}`);
+        logError(`Remote schedules error: ${error.message}`);
       }
 
       // Heartbeat checks (internally throttled: 10min fast, 1hr slow)