cli4ai 0.8.2 → 0.8.3

package/src/core/routines.ts

@@ -10,9 +10,10 @@
  * - within a scope: .routine.json before .routine.sh
  */
 
-import { existsSync, readdirSync, statSync } from 'fs';
+import { existsSync, readdirSync, statSync, readFileSync } from 'fs';
 import { resolve } from 'path';
 import { ensureCli4aiHome, ensureLocalDir, ROUTINES_DIR, LOCAL_ROUTINES_DIR } from './config.js';
+import { validateScheduleConfig, type RoutineSchedule } from './routine-engine.js';
 
 export type RoutineKind = 'json' | 'bash';
 export type RoutineScope = 'local' | 'global';
@@ -109,3 +110,59 @@ export function resolveRoutine(name: string, projectDir: string, options: Resolv
   return null;
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEDULED ROUTINES
+// ═══════════════════════════════════════════════════════════════════════════
+
+export interface ScheduledRoutineInfo extends RoutineInfo {
+  schedule: RoutineSchedule;
+}
+
+/**
+ * Get all routines that have a schedule defined.
+ * Only JSON routines can have schedules (bash scripts cannot).
+ * Searches both local (if projectDir provided) and global routines.
+ */
+export function getScheduledRoutines(projectDir?: string): ScheduledRoutineInfo[] {
+  const results: ScheduledRoutineInfo[] = [];
+  const seen = new Set<string>();
+
+  // Collect all JSON routines
+  const allRoutines: RoutineInfo[] = [];
+
+  if (projectDir) {
+    allRoutines.push(...getLocalRoutines(projectDir).filter(r => r.kind === 'json'));
+  }
+  allRoutines.push(...getGlobalRoutines().filter(r => r.kind === 'json'));
+
+  for (const routine of allRoutines) {
+    // Skip if we've already processed a routine with this name (local takes precedence)
+    if (seen.has(routine.name)) continue;
+    seen.add(routine.name);
+
+    try {
+      const content = readFileSync(routine.path, 'utf-8');
+      const data = JSON.parse(content);
+
+      if (data.schedule && typeof data.schedule === 'object') {
+        // Check if schedule is enabled (defaults to true)
+        const enabled = (data.schedule as Record<string, unknown>).enabled !== false;
+        if (!enabled) continue;
+
+        try {
+          const schedule = validateScheduleConfig(data.schedule, routine.path);
+          results.push({
+            ...routine,
+            schedule
+          });
+        } catch {
+          // Skip routines with invalid schedule configs (don't crash the scheduler)
+        }
+      }
+    } catch {
+      // Skip invalid JSON files
+    }
+  }
+
+  return results;
+}

package/src/core/scheduler-daemon.ts

@@ -0,0 +1,94 @@
+#!/usr/bin/env bun
+/**
+ * Scheduler daemon entry point.
+ *
+ * This script runs as a background process and manages scheduled routine execution.
+ * It's spawned by `cli4ai scheduler start` with detached mode.
+ *
+ * Usage: bun scheduler-daemon.ts [--project-dir <dir>]
+ */
+
+import { Scheduler, writeDaemonPid, removeDaemonPid, appendSchedulerLog, SCHEDULER_LOG_FILE, ensureSchedulerDirs } from './scheduler.js';
+import { createWriteStream } from 'fs';
+import { ensureCli4aiHome } from './config.js';
+
+// Parse arguments
+const args = process.argv.slice(2);
+let projectDir: string | undefined;
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--project-dir' && args[i + 1]) {
+    projectDir = args[i + 1];
+    i++;
+  }
+}
+
+// Ensure directories exist
+ensureCli4aiHome();
+ensureSchedulerDirs();
+
+// Redirect stdout/stderr to log file (when running detached)
+if (process.env.CLI4AI_DAEMON === 'true') {
+  const logStream = createWriteStream(SCHEDULER_LOG_FILE, { flags: 'a' });
+
+  // Redirect console output
+  const originalLog = console.log;
+  const originalError = console.error;
+
+  console.log = (...args) => {
+    const message = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+    logStream.write(`[${new Date().toISOString()}] [STDOUT] ${message}\n`);
+  };
+
+  console.error = (...args) => {
+    const message = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+    logStream.write(`[${new Date().toISOString()}] [STDERR] ${message}\n`);
+  };
+
+  // Handle uncaught errors
+  process.on('uncaughtException', (err) => {
+    appendSchedulerLog('error', `Uncaught exception: ${err.message}\n${err.stack}`);
+    process.exit(1);
+  });
+
+  process.on('unhandledRejection', (reason) => {
+    appendSchedulerLog('error', `Unhandled rejection: ${reason}`);
+  });
+}
+
+// Write PID file
+writeDaemonPid(process.pid);
+appendSchedulerLog('info', `Daemon started with PID ${process.pid}`);
+
+// Create and start scheduler
+const scheduler = new Scheduler({ projectDir });
+
+// Handle shutdown signals
+let shuttingDown = false;
+
+async function shutdown(signal: string): Promise<void> {
+  if (shuttingDown) return;
+  shuttingDown = true;
+
+  appendSchedulerLog('info', `Received ${signal}, shutting down...`);
+
+  try {
+    await scheduler.stop();
+    removeDaemonPid();
+    appendSchedulerLog('info', 'Daemon stopped gracefully');
+  } catch (err) {
+    appendSchedulerLog('error', `Error during shutdown: ${err instanceof Error ? err.message : String(err)}`);
+  }
+
+  process.exit(0);
+}
+
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+process.on('SIGINT', () => shutdown('SIGINT'));
+
+// Start the scheduler
+scheduler.start().catch(err => {
+  appendSchedulerLog('error', `Failed to start scheduler: ${err instanceof Error ? err.message : String(err)}`);
+  removeDaemonPid();
+  process.exit(1);
+});

package/src/core/scheduler.test.ts

@@ -0,0 +1,291 @@
+/**
+ * Tests for scheduler core functionality.
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { rmSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import {
+  parseInterval,
+  getNextRunTime,
+  isDaemonRunning,
+  getDaemonPid,
+  writeDaemonPid,
+  removeDaemonPid,
+  loadSchedulerState,
+  saveSchedulerState,
+  saveRunRecord,
+  getRunHistory,
+  Scheduler,
+  SCHEDULER_PID_FILE,
+  SCHEDULER_STATE_FILE,
+  SCHEDULER_RUNS_DIR,
+  type SchedulerState,
+  type SchedulerRunRecord
+} from './scheduler.js';
+import { validateScheduleConfig, type RoutineSchedule } from './routine-engine.js';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// INTERVAL PARSING TESTS
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('parseInterval', () => {
+  test('parses seconds', () => {
+    expect(parseInterval('30s')).toBe(30 * 1000);
+    expect(parseInterval('1s')).toBe(1000);
+    expect(parseInterval('120s')).toBe(120 * 1000);
+  });
+
+  test('parses minutes', () => {
+    expect(parseInterval('5m')).toBe(5 * 60 * 1000);
+    expect(parseInterval('1m')).toBe(60 * 1000);
+    expect(parseInterval('60m')).toBe(60 * 60 * 1000);
+  });
+
+  test('parses hours', () => {
+    expect(parseInterval('1h')).toBe(60 * 60 * 1000);
+    expect(parseInterval('24h')).toBe(24 * 60 * 60 * 1000);
+  });
+
+  test('parses days', () => {
+    expect(parseInterval('1d')).toBe(24 * 60 * 60 * 1000);
+    expect(parseInterval('7d')).toBe(7 * 24 * 60 * 60 * 1000);
+  });
+
+  test('throws on invalid format', () => {
+    expect(() => parseInterval('10')).toThrow();
+    expect(() => parseInterval('10x')).toThrow();
+    expect(() => parseInterval('abc')).toThrow();
+    expect(() => parseInterval('')).toThrow();
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// NEXT RUN TIME TESTS
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('getNextRunTime', () => {
+  test('calculates next run from interval', () => {
+    const now = new Date('2024-01-01T10:00:00Z');
+    const schedule: RoutineSchedule = { interval: '1h' };
+
+    const nextRun = getNextRunTime(schedule, now);
+
+    expect(nextRun).not.toBeNull();
+    expect(nextRun!.getTime()).toBe(now.getTime() + (60 * 60 * 1000));
+  });
+
+  test('calculates next run from cron', () => {
+    const now = new Date('2024-01-01T10:30:00Z');
+    const schedule: RoutineSchedule = { cron: '0 * * * *' }; // Every hour at :00
+
+    const nextRun = getNextRunTime(schedule, now);
+
+    expect(nextRun).not.toBeNull();
+    expect(nextRun!.getMinutes()).toBe(0);
+    expect(nextRun!.getHours()).toBe(11); // Next hour
+  });
+
+  test('returns earliest when both cron and interval specified', () => {
+    const now = new Date('2024-01-01T10:55:00Z');
+    const schedule: RoutineSchedule = {
+      cron: '0 * * * *',  // 5 minutes until :00
+      interval: '30m'      // 30 minutes
+    };
+
+    const nextRun = getNextRunTime(schedule, now);
+
+    expect(nextRun).not.toBeNull();
+    // Should be the cron time (5 min) not interval (30 min)
+    expect(nextRun!.getMinutes()).toBe(0);
+  });
+
+  test('returns null for invalid schedule', () => {
+    const schedule: RoutineSchedule = {} as RoutineSchedule;
+    const nextRun = getNextRunTime(schedule);
+    expect(nextRun).toBeNull();
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEDULE VALIDATION TESTS
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('validateScheduleConfig', () => {
+  test('validates interval schedule', () => {
+    const schedule = validateScheduleConfig({ interval: '1h' });
+    expect(schedule.interval).toBe('1h');
+  });
+
+  test('validates cron schedule', () => {
+    const schedule = validateScheduleConfig({ cron: '0 9 * * *' });
+    expect(schedule.cron).toBe('0 9 * * *');
+  });
+
+  test('validates all optional fields', () => {
+    const schedule = validateScheduleConfig({
+      interval: '1h',
+      timezone: 'Pacific/Auckland',
+      enabled: true,
+      retries: 3,
+      retryDelayMs: 60000,
+      concurrency: 'skip'
+    });
+
+    expect(schedule.timezone).toBe('Pacific/Auckland');
+    expect(schedule.enabled).toBe(true);
+    expect(schedule.retries).toBe(3);
+    expect(schedule.retryDelayMs).toBe(60000);
+    expect(schedule.concurrency).toBe('skip');
+  });
+
+  test('throws when missing cron and interval', () => {
+    expect(() => validateScheduleConfig({})).toThrow('Schedule must have "cron" or "interval"');
+  });
+
+  test('throws on invalid interval format', () => {
+    expect(() => validateScheduleConfig({ interval: 'invalid' })).toThrow('must be like "30s"');
+  });
+
+  test('throws on invalid cron format', () => {
+    expect(() => validateScheduleConfig({ cron: '* *' })).toThrow('must have 5 or 6 fields');
+  });
+
+  test('throws on invalid retries', () => {
+    expect(() => validateScheduleConfig({ interval: '1h', retries: -1 })).toThrow('non-negative integer');
+    expect(() => validateScheduleConfig({ interval: '1h', retries: 'abc' })).toThrow('non-negative integer');
+  });
+
+  test('throws on invalid concurrency', () => {
+    expect(() => validateScheduleConfig({ interval: '1h', concurrency: 'invalid' })).toThrow('"skip" or "queue"');
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// STATE MANAGEMENT TESTS
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('state management', () => {
+  // Note: These tests use the actual ~/.cli4ai/scheduler directory
+  // because paths are resolved at module import time
+
+  test('saves and loads scheduler state', () => {
+    // Clean up first
+    if (existsSync(SCHEDULER_STATE_FILE)) {
+      rmSync(SCHEDULER_STATE_FILE);
+    }
+
+    const state: SchedulerState = {
+      version: 1,
+      startedAt: new Date().toISOString(),
+      routines: {
+        'test-routine': {
+          name: 'test-routine',
+          path: '/path/to/routine.json',
+          schedule: { interval: '1h' },
+          nextRunAt: new Date().toISOString(),
+          lastRunAt: null,
+          lastStatus: null,
+          running: false,
+          retryCount: 0
+        }
+      }
+    };
+
+    saveSchedulerState(state);
+    const loaded = loadSchedulerState();
+
+    expect(loaded).not.toBeNull();
+    expect(loaded!.version).toBe(1);
+    expect(loaded!.routines['test-routine'].name).toBe('test-routine');
+
+    // Clean up
+    rmSync(SCHEDULER_STATE_FILE);
+  });
+
+  test('returns null when no state file exists', () => {
+    // Ensure no state file exists
+    if (existsSync(SCHEDULER_STATE_FILE)) {
+      rmSync(SCHEDULER_STATE_FILE);
+    }
+
+    const state = loadSchedulerState();
+    expect(state).toBeNull();
+  });
+
+  test('saves and retrieves run records', () => {
+    // Clean up existing run files for this test
+    if (existsSync(SCHEDULER_RUNS_DIR)) {
+      const files = readdirSync(SCHEDULER_RUNS_DIR);
+      for (const f of files) {
+        if (f.startsWith('test-routine-')) {
+          rmSync(join(SCHEDULER_RUNS_DIR, f));
+        }
+      }
+    }
+
+    const record: SchedulerRunRecord = {
+      routine: 'test-routine',
+      startedAt: new Date().toISOString(),
+      finishedAt: new Date().toISOString(),
+      status: 'success',
+      exitCode: 0,
+      durationMs: 1234,
+      retryAttempt: 0
+    };
+
+    saveRunRecord(record);
+    const history = getRunHistory('test-routine');
+
+    expect(history.length).toBeGreaterThanOrEqual(1);
+    expect(history[0].routine).toBe('test-routine');
+    expect(history[0].status).toBe('success');
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PID FILE TESTS
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('daemon PID management', () => {
+  // Note: These tests use the actual ~/.cli4ai/scheduler directory
+  // because paths are resolved at module import time
+
+  beforeEach(() => {
+    // Clean up any existing PID file
+    if (existsSync(SCHEDULER_PID_FILE)) {
+      rmSync(SCHEDULER_PID_FILE);
+    }
+  });
+
+  afterEach(() => {
+    // Clean up
+    if (existsSync(SCHEDULER_PID_FILE)) {
+      rmSync(SCHEDULER_PID_FILE);
+    }
+  });
+
+  test('writes and reads PID file', () => {
+    writeDaemonPid(12345);
+    const pid = getDaemonPid();
+    expect(pid).toBe(12345);
+  });
+
+  test('removes PID file', () => {
+    writeDaemonPid(12345);
+    removeDaemonPid();
+    const pid = getDaemonPid();
+    expect(pid).toBeNull();
+  });
+
+  test('returns null when no PID file', () => {
+    const pid = getDaemonPid();
+    expect(pid).toBeNull();
+  });
+
+  test('isDaemonRunning returns false for non-existent process', () => {
+    writeDaemonPid(999999); // Unlikely to be running
+    const running = isDaemonRunning();
+    expect(running).toBe(false);
+  });
+});