cli4ai 0.8.1 → 0.8.3

package/src/commands/scheduler.ts

@@ -0,0 +1,438 @@
+/**
+ * Scheduler CLI commands.
+ *
+ * cli4ai scheduler start [--foreground]   # Start daemon
+ * cli4ai scheduler stop                    # Stop daemon
+ * cli4ai scheduler status                  # Show status + upcoming runs
+ * cli4ai scheduler logs [routine]          # View logs
+ * cli4ai scheduler history [routine]       # View execution history
+ * cli4ai scheduler run <routine>           # Manual trigger
+ */
+
+import { spawn } from 'child_process';
+import { readFileSync, existsSync, createReadStream } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { output, outputError, log } from '../lib/cli.js';
+import {
+  isDaemonRunning,
+  getDaemonPid,
+  removeDaemonPid,
+  loadSchedulerState,
+  getRunHistory,
+  getNextRunTime,
+  Scheduler,
+  SCHEDULER_LOG_FILE,
+  SCHEDULER_PID_FILE
+} from '../core/scheduler.js';
+import { getScheduledRoutines } from '../core/routines.js';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEDULER START
+// ═══════════════════════════════════════════════════════════════════════════
+
+interface SchedulerStartOptions {
+  foreground?: boolean;
+}
+
+export async function schedulerStartCommand(options: SchedulerStartOptions): Promise<void> {
+  // Check if already running
+  if (isDaemonRunning()) {
+    const pid = getDaemonPid();
+    outputError('INVALID_INPUT', `Scheduler is already running (PID ${pid})`, {
+      hint: 'Use "cli4ai scheduler stop" to stop it first'
+    });
+    return;
+  }
+
+  // Clean up stale PID file
+  if (existsSync(SCHEDULER_PID_FILE)) {
+    removeDaemonPid();
+  }
+
+  if (options.foreground) {
+    // Run in foreground (blocking)
+    log('Starting scheduler in foreground mode...');
+    log('Press Ctrl+C to stop');
+
+    const scheduler = new Scheduler({ projectDir: process.cwd() });
+    await scheduler.start();
+
+    // Keep running until signal
+    await new Promise<void>((resolve) => {
+      process.on('SIGINT', async () => {
+        log('\nStopping scheduler...');
+        await scheduler.stop();
+        resolve();
+      });
+      process.on('SIGTERM', async () => {
+        await scheduler.stop();
+        resolve();
+      });
+    });
+
+    output({ status: 'stopped' });
+    return;
+  }
+
+  // Run as daemon (background)
+  const daemonScript = resolve(dirname(fileURLToPath(import.meta.url)), '../core/scheduler-daemon.ts');
+
+  // Spawn with detached mode
+  const child = spawn('bun', [daemonScript, '--project-dir', process.cwd()], {
+    detached: true,
+    stdio: 'ignore',
+    env: {
+      ...process.env,
+      CLI4AI_DAEMON: 'true'
+    }
+  });
+
+  // Unref to allow parent to exit
+  child.unref();
+
+  // Wait a moment for the daemon to write its PID
+  await new Promise(r => setTimeout(r, 500));
+
+  const pid = getDaemonPid();
+  if (pid && isDaemonRunning()) {
+    log(`Scheduler daemon started (PID ${pid})`);
+    output({ status: 'started', pid });
+  } else {
+    outputError('API_ERROR', 'Failed to start scheduler daemon', {
+      hint: 'Check logs with "cli4ai scheduler logs"'
+    });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEDULER STOP
+// ═══════════════════════════════════════════════════════════════════════════
+
+export async function schedulerStopCommand(): Promise<void> {
+  const pid = getDaemonPid();
+
+  if (!pid) {
+    outputError('NOT_FOUND', 'Scheduler daemon is not running');
+    return;
+  }
+
+  if (!isDaemonRunning()) {
+    // Clean up stale PID file
+    removeDaemonPid();
+    log('Scheduler was not running (cleaned up stale PID file)');
+    output({ status: 'stopped', pid: null });
+    return;
+  }
+
+  log(`Stopping scheduler daemon (PID ${pid})...`);
+
+  try {
+    // Send SIGTERM for graceful shutdown
+    process.kill(pid, 'SIGTERM');
+
+    // Wait for process to exit (up to 10 seconds)
+    const maxWait = 10000;
+    const checkInterval = 100;
+    let waited = 0;
+
+    while (waited < maxWait) {
+      await new Promise(r => setTimeout(r, checkInterval));
+      waited += checkInterval;
+
+      if (!isDaemonRunning()) {
+        break;
+      }
+    }
+
+    if (isDaemonRunning()) {
+      // Force kill if still running
+      log('Scheduler did not stop gracefully, sending SIGKILL...');
+      process.kill(pid, 'SIGKILL');
+      await new Promise(r => setTimeout(r, 500));
+    }
+
+    removeDaemonPid();
+    log('Scheduler daemon stopped');
+    output({ status: 'stopped', pid });
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'ESRCH') {
+      // Process doesn't exist
+      removeDaemonPid();
+      log('Scheduler was not running (cleaned up stale PID file)');
+      output({ status: 'stopped', pid: null });
+    } else {
+      outputError('API_ERROR', `Failed to stop scheduler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEDULER STATUS
+// ═══════════════════════════════════════════════════════════════════════════
+
+export async function schedulerStatusCommand(): Promise<void> {
+  const pid = getDaemonPid();
+  const running = isDaemonRunning();
+
+  // Get scheduled routines
+  const scheduledRoutines = getScheduledRoutines(process.cwd());
+  const state = loadSchedulerState();
+
+  if (!running) {
+    log('Scheduler: not running');
+
+    if (scheduledRoutines.length === 0) {
+      log('\nNo scheduled routines found.');
+      log('Add a "schedule" field to your .routine.json files to enable scheduling.');
+    } else {
+      log(`\nFound ${scheduledRoutines.length} scheduled routine(s):`);
+      for (const routine of scheduledRoutines) {
+        const scheduleStr = routine.schedule.cron
+          ? `cron: ${routine.schedule.cron}`
+          : `interval: ${routine.schedule.interval}`;
+        log(`  - ${routine.name} (${scheduleStr})`);
+      }
+      log('\nStart the scheduler with: cli4ai scheduler start');
+    }
+
+    output({
+      running: false,
+      pid: null,
+      routines: scheduledRoutines.map(r => ({
+        name: r.name,
+        schedule: r.schedule,
+        path: r.path
+      }))
+    });
+    return;
+  }
+
+  log(`Scheduler: running (PID ${pid})`);
+
+  if (state) {
+    log(`Started: ${state.startedAt}`);
+
+    const routineStates = Object.values(state.routines);
+    if (routineStates.length === 0) {
+      log('\nNo scheduled routines.');
+    } else {
+      log(`\nScheduled routines (${routineStates.length}):`);
+      log('');
+
+      for (const routine of routineStates) {
+        const scheduleStr = routine.schedule.cron
+          ? `cron: ${routine.schedule.cron}`
+          : `interval: ${routine.schedule.interval}`;
+
+        const statusIcon = routine.running ? '⏳' :
+          routine.lastStatus === 'success' ? '✓' :
+          routine.lastStatus === 'failed' ? '✗' : '○';
+
+        log(`  ${statusIcon} ${routine.name}`);
+        log(`    Schedule: ${scheduleStr}`);
+
+        if (routine.nextRunAt) {
+          const nextRun = new Date(routine.nextRunAt);
+          const now = new Date();
+          const diffMs = nextRun.getTime() - now.getTime();
+          const diffMins = Math.round(diffMs / 60000);
+
+          if (diffMins < 1) {
+            log(`    Next run: in < 1 minute`);
+          } else if (diffMins < 60) {
+            log(`    Next run: in ${diffMins} minute${diffMins === 1 ? '' : 's'}`);
+          } else {
+            const diffHours = Math.round(diffMins / 60);
+            log(`    Next run: in ${diffHours} hour${diffHours === 1 ? '' : 's'}`);
+          }
+        }
+
+        if (routine.lastRunAt) {
+          log(`    Last run: ${routine.lastRunAt} (${routine.lastStatus})`);
+        }
+
+        log('');
+      }
+    }
+  }
+
+  output({
+    running: true,
+    pid,
+    startedAt: state?.startedAt,
+    routines: state ? Object.values(state.routines) : []
+  });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEDULER LOGS
+// ═══════════════════════════════════════════════════════════════════════════
+
+interface SchedulerLogsOptions {
+  follow?: boolean;
+  lines?: number;
+}
+
+export async function schedulerLogsCommand(options: SchedulerLogsOptions): Promise<void> {
+  if (!existsSync(SCHEDULER_LOG_FILE)) {
+    log('No scheduler logs found.');
+    output({ logs: [] });
+    return;
+  }
+
+  const lines = options.lines ?? 50;
+
+  if (options.follow) {
+    // Tail -f mode
+    log(`Tailing scheduler logs (${SCHEDULER_LOG_FILE})...`);
+    log('Press Ctrl+C to stop\n');
+
+    // Read initial content
+    const content = readFileSync(SCHEDULER_LOG_FILE, 'utf-8');
+    const allLines = content.split('\n');
+    const lastLines = allLines.slice(-lines);
+    process.stdout.write(lastLines.join('\n') + '\n');
+
+    // Watch for new content
+    const { watch } = await import('fs');
+    let lastSize = content.length;
+
+    const watcher = watch(SCHEDULER_LOG_FILE, (eventType) => {
+      if (eventType === 'change') {
+        const newContent = readFileSync(SCHEDULER_LOG_FILE, 'utf-8');
+        if (newContent.length > lastSize) {
+          process.stdout.write(newContent.slice(lastSize));
+          lastSize = newContent.length;
+        }
+      }
+    });
+
+    // Keep running until interrupted
+    await new Promise<void>((resolve) => {
+      let closed = false;
+      const closeWatcher = () => {
+        if (closed) return;
+        closed = true;
+        try {
+          watcher.close();
+        } catch {
+          // ignore
+        }
+      };
+
+      const stop = () => {
+        closeWatcher();
+        resolve();
+      };
+
+      process.once('exit', closeWatcher);
+      process.once('SIGINT', stop);
+      process.once('SIGTERM', stop);
+    });
+  } else {
+    // Read last N lines
+    const content = readFileSync(SCHEDULER_LOG_FILE, 'utf-8');
+    const allLines = content.split('\n').filter(l => l.trim());
+    const lastLines = allLines.slice(-lines);
+
+    for (const line of lastLines) {
+      log(line);
+    }
+
+    output({ logs: lastLines });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEDULER HISTORY
+// ═══════════════════════════════════════════════════════════════════════════
+
+interface SchedulerHistoryOptions {
+  limit?: number;
+}
+
+export async function schedulerHistoryCommand(routineName?: string, options: SchedulerHistoryOptions = {}): Promise<void> {
+  const limit = options.limit ?? 20;
+  const history = getRunHistory(routineName, limit);
+
+  if (history.length === 0) {
+    log(routineName
+      ? `No execution history found for routine: ${routineName}`
+      : 'No execution history found.');
+    output({ history: [] });
+    return;
+  }
+
+  log(routineName
+    ? `Execution history for ${routineName} (last ${history.length}):`
+    : `Execution history (last ${history.length}):`);
+  log('');
+
+  for (const record of history) {
+    const statusIcon = record.status === 'success' ? '✓' : '✗';
+    const duration = record.durationMs < 1000
+      ? `${record.durationMs}ms`
+      : `${(record.durationMs / 1000).toFixed(1)}s`;
+
+    log(`  ${statusIcon} ${record.routine}`);
+    log(`    Started: ${record.startedAt}`);
+    log(`    Duration: ${duration}`);
+    if (record.retryAttempt > 0) {
+      log(`    Retry: #${record.retryAttempt}`);
+    }
+    if (record.error) {
+      log(`    Error: ${record.error}`);
+    }
+    log('');
+  }
+
+  output({ history });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEDULER RUN
+// ═══════════════════════════════════════════════════════════════════════════
+
+export async function schedulerRunCommand(routineName: string): Promise<void> {
+  // Check if routine exists and is scheduled
+  const scheduledRoutines = getScheduledRoutines(process.cwd());
+  const routine = scheduledRoutines.find(r => r.name === routineName);
+
+  if (!routine) {
+    // Check if it exists but isn't scheduled
+    const { resolveRoutine } = await import('../core/routines.js');
+    const exists = resolveRoutine(routineName, process.cwd());
+
+    if (exists) {
+      outputError('NOT_FOUND', `Routine "${routineName}" exists but has no schedule configured`, {
+        hint: 'Add a "schedule" field to enable scheduling, or use "cli4ai routines run" for one-time execution'
+      });
+    } else {
+      outputError('NOT_FOUND', `Routine not found: ${routineName}`);
+    }
+    return;
+  }
+
+  log(`Running routine: ${routineName}`);
+
+  const scheduler = new Scheduler({ projectDir: process.cwd() });
+  scheduler.refreshRoutines();
+
+  try {
+    const record = await scheduler.runNow(routineName);
+
+    if (record.status === 'success') {
+      log(`Routine completed successfully in ${record.durationMs}ms`);
+    } else {
+      log(`Routine failed (exit code ${record.exitCode})`);
+      if (record.error) {
+        log(`Error: ${record.error}`);
+      }
+    }
+
+    output(record);
+  } catch (err) {
+    outputError('API_ERROR', `Failed to run routine: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}

package/src/commands/secrets.ts

@@ -5,7 +5,9 @@
 import { createInterface } from 'readline';
 import { resolve } from 'path';
 import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
 import { output, outputError, log } from '../lib/cli.js';
+
 import {
   getSecret,
   setSecret,
@@ -16,6 +18,19 @@ import {
 } from '../core/secrets.js';
 import { findPackage } from '../core/config.js';
 
+/**
+ * Expand ~ to home directory in paths
+ */
+function expandTilde(path: string): string {
+  if (path.startsWith('~/')) {
+    return resolve(homedir(), path.slice(2));
+  }
+  if (path === '~') {
+    return homedir();
+  }
+  return path;
+}
+
 interface SecretsOptions {
   package?: string;
 }
@@ -86,7 +101,9 @@ export async function secretsSetCommand(key: string, value?: string): Promise<vo
     outputError('INVALID_INPUT', 'Secret value cannot be empty');
   }
 
-  setSecret(key, value);
+  // Expand ~ to home directory for paths
+  const expandedValue = expandTilde(value);
+  setSecret(key, expandedValue);
   log(`✓ Secret '${key}' saved to vault`);
 
   output({ key, status: 'saved' });
@@ -259,7 +276,9 @@ export async function secretsInitCommand(packageName?: string, options?: Secrets
     const value = await prompt(`  Enter ${key}: `, true);
 
     if (value) {
-      setSecret(key, value);
+      // Expand ~ to home directory for paths
+      const expandedValue = expandTilde(value);
+      setSecret(key, expandedValue);
       log(`  ✓ ${key} saved`);
       configured.push(key);
     } else {

package/src/commands/update.ts

@@ -179,14 +179,13 @@ export async function updateCommand(options: UpdateOptions): Promise<void> {
 
   // Update all packages in parallel
   if (toUpdate.length > 0) {
-    log(`\n${BOLD}Updating ${toUpdate.length} package${toUpdate.length !== 1 ? 's' : ''} in parallel...${RESET}`);
+    log(`\n${BOLD}Updating ${toUpdate.length} package${toUpdate.length !== 1 ? 's' : ''}...${RESET}`);
 
-    const updatePromises = toUpdate.map(async (pkg) => {
+    const updateResults: Array<(typeof toUpdate)[number] & { success: boolean }> = [];
+    for (const pkg of toUpdate) {
       const success = await updatePackageAsync(pkg.npmName);
-      return { ...pkg, success };
-    });
-
-    const updateResults = await Promise.all(updatePromises);
+      updateResults.push({ ...pkg, success });
+    }
 
     log('');
     for (const result of updateResults) {
@@ -204,7 +203,7 @@ export async function updateCommand(options: UpdateOptions): Promise<void> {
   const updated = results.filter(r => r.status === 'updated').length;
   const failed = results.filter(r => r.status === 'failed').length;
 
-  console.log('');
+  log('');
   if (updated > 0) {
     log(`${GREEN}${updated} package${updated !== 1 ? 's' : ''} updated${RESET}`);
   }
@@ -214,5 +213,5 @@ export async function updateCommand(options: UpdateOptions): Promise<void> {
   if (updated === 0 && failed === 0) {
     log(`${GREEN}All packages are up to date${RESET}`);
   }
-  console.log('');
+  log('');
 }

package/src/core/config.test.ts

@@ -29,7 +29,7 @@ describe('config', () => {
 
   describe('DEFAULT_CONFIG', () => {
     test('has expected defaults', () => {
-      expect(DEFAULT_CONFIG.registry).toBe('https://registry.cliforai.com');
+      expect(DEFAULT_CONFIG.registry).toBe('https://registry.cli4ai.com');
       expect(DEFAULT_CONFIG.localRegistries).toEqual([]);
       expect(DEFAULT_CONFIG.defaultRuntime).toBe('bun');
       expect(DEFAULT_CONFIG.mcp.transport).toBe('stdio');