cli4ai 0.8.2 → 0.9.0

package/src/core/lockfile.ts

@@ -8,7 +8,7 @@
  * to detect tampered packages.
  */
 
-import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { readFileSync, writeFileSync, renameSync, existsSync, readdirSync, statSync } from 'fs';
 import { resolve, join, relative } from 'path';
 import { createHash } from 'crypto';
 
@@ -211,7 +211,9 @@ export function loadLockfile(projectDir: string): Lockfile {
 export function saveLockfile(projectDir: string, lockfile: Lockfile): void {
   const lockfilePath = getLockfilePath(projectDir);
   const content = JSON.stringify(lockfile, null, 2) + '\n';
-  writeFileSync(lockfilePath, content);
+  const tmpPath = lockfilePath + '.tmp';
+  writeFileSync(tmpPath, content);
+  renameSync(tmpPath, lockfilePath);
 }
 
 /**

package/src/core/manifest.test.ts

@@ -2,7 +2,7 @@
  * Tests for manifest.ts
  */
 
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
 import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
@@ -304,7 +304,7 @@ describe('manifest', () => {
       expect(manifest.name).toBe('my-tool');
       expect(manifest.version).toBe('1.0.0');
       expect(manifest.entry).toBe('run.ts');
-      expect(manifest.runtime).toBe('bun');
+      expect(manifest.runtime).toBe('node');
     });
 
     test('normalizes name', () => {

package/src/core/manifest.ts

@@ -73,8 +73,8 @@ export interface Manifest {
   homepage?: string;
   keywords?: string[];
 
-  // Runtime (bun or node only - deno not supported)
-  runtime?: 'bun' | 'node';
+  // Runtime (node is default, bun kept for backwards compatibility)
+  runtime?: 'node' | 'bun';
 
   // Commands (for MCP generation)
   commands?: Record<string, CommandDef>;
@@ -134,6 +134,14 @@ export function validateManifest(manifest: unknown, source?: string): Manifest {
     });
   }
 
+  // SECURITY: Validate entry is a relative path that stays within package directory
+  if (m.entry.startsWith('/') || m.entry.startsWith('\\') || m.entry.includes('..')) {
+    throw new ManifestValidationError(
+      'Invalid "entry" - must be a relative path without ".." (security: path traversal)',
+      { source, got: m.entry }
+    );
+  }
+
   // Optional: runtime (deno not supported)
   if (m.runtime !== undefined && !['bun', 'node'].includes(m.runtime as string)) {
     throw new ManifestValidationError('Invalid "runtime" (must be bun or node)', {
@@ -230,7 +238,7 @@ export function loadFromPackageJson(dir: string): Manifest | null {
       description: pkg.description,
       author: pkg.author,
       license: pkg.license,
-      runtime: 'bun',
+      runtime: 'node',
       keywords: pkg.keywords
     };
   } catch {
@@ -312,7 +320,7 @@ export function createManifest(name: string, options: Partial<Manifest> = {}): M
     name: name.toLowerCase().replace(/[^a-z0-9-]/g, '-'),
     version: '1.0.0',
     entry: 'run.ts',
-    runtime: 'bun',
+    runtime: 'node',
     description: options.description || `${name} tool`,
     ...options
   };

package/src/core/routine-engine.test.ts

@@ -2,7 +2,7 @@
  * Tests for routine-engine.ts
  */
 
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
 import { mkdtempSync, rmSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';

package/src/core/routine-engine.ts

@@ -38,6 +38,27 @@ export class RoutineTemplateError extends Error {
 
 export type StepCapture = 'inherit' | 'text' | 'json';
 
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEDULE TYPES
+// ═══════════════════════════════════════════════════════════════════════════
+
+export interface RoutineSchedule {
+  /** Cron expression (e.g., "0 9 * * *" for 9am daily) */
+  cron?: string;
+  /** Simple interval (e.g., "30s", "5m", "1h", "1d") */
+  interval?: string;
+  /** IANA timezone (e.g., "Pacific/Auckland"). Defaults to system timezone */
+  timezone?: string;
+  /** Whether this schedule is active. Defaults to true */
+  enabled?: boolean;
+  /** Number of retry attempts on failure. Defaults to 0 */
+  retries?: number;
+  /** Delay between retries in milliseconds. Defaults to 60000 */
+  retryDelayMs?: number;
+  /** What to do if previous run is still executing. Defaults to 'skip' */
+  concurrency?: 'skip' | 'queue';
+}
+
 export interface RoutineVarDef {
   default?: string;
 }
@@ -81,6 +102,8 @@ export interface RoutineDefinition {
   description?: string;
   mcp?: { expose?: boolean; description?: string };
   vars?: Record<string, RoutineVarDef>;
+  /** Schedule configuration for automatic execution */
+  schedule?: RoutineSchedule;
   steps: RoutineStep[];
   result?: unknown;
 }
@@ -140,6 +163,80 @@ export function loadRoutineDefinition(path: string): RoutineDefinition {
   return validateRoutineDefinition(data, path);
 }
 
+const INTERVAL_PATTERN = /^(\d+)(s|m|h|d)$/;
+
+/**
+ * Validate a schedule configuration.
+ * Exported for use by scheduler and tests.
+ */
+export function validateScheduleConfig(schedule: unknown, source?: string): RoutineSchedule {
+  if (!schedule || typeof schedule !== 'object') {
+    throw new RoutineValidationError('Schedule must be an object', { source });
+  }
+
+  const s = schedule as Record<string, unknown>;
+
+  // Must have either cron or interval (or both)
+  if (s.cron === undefined && s.interval === undefined) {
+    throw new RoutineValidationError('Schedule must have "cron" or "interval"', { source });
+  }
+
+  // Validate cron (basic format check - full validation happens at runtime with cron-parser)
+  if (s.cron !== undefined) {
+    if (typeof s.cron !== 'string' || s.cron.trim().length === 0) {
+      throw new RoutineValidationError('Schedule "cron" must be a non-empty string', { source, got: s.cron });
+    }
+    // Basic cron format: should have 5 space-separated parts
+    const parts = s.cron.trim().split(/\s+/);
+    if (parts.length < 5 || parts.length > 6) {
+      throw new RoutineValidationError('Schedule "cron" must have 5 or 6 fields', { source, got: s.cron });
+    }
+  }
+
+  // Validate interval
+  if (s.interval !== undefined) {
+    if (typeof s.interval !== 'string') {
+      throw new RoutineValidationError('Schedule "interval" must be a string', { source, got: s.interval });
+    }
+    if (!INTERVAL_PATTERN.test(s.interval)) {
+      throw new RoutineValidationError('Schedule "interval" must be like "30s", "5m", "1h", or "1d"', { source, got: s.interval });
+    }
+  }
+
+  // Validate timezone (just check it's a string - actual validation happens at runtime)
+  if (s.timezone !== undefined && typeof s.timezone !== 'string') {
+    throw new RoutineValidationError('Schedule "timezone" must be a string', { source, got: s.timezone });
+  }
+
+  // Validate enabled
+  if (s.enabled !== undefined && typeof s.enabled !== 'boolean') {
+    throw new RoutineValidationError('Schedule "enabled" must be a boolean', { source, got: s.enabled });
+  }
+
+  // Validate retries
+  if (s.retries !== undefined) {
+    if (typeof s.retries !== 'number' || !Number.isInteger(s.retries) || s.retries < 0) {
+      throw new RoutineValidationError('Schedule "retries" must be a non-negative integer', { source, got: s.retries });
+    }
+  }
+
+  // Validate retryDelayMs
+  if (s.retryDelayMs !== undefined) {
+    if (typeof s.retryDelayMs !== 'number' || !Number.isInteger(s.retryDelayMs) || s.retryDelayMs < 0) {
+      throw new RoutineValidationError('Schedule "retryDelayMs" must be a non-negative integer', { source, got: s.retryDelayMs });
+    }
+  }
+
+  // Validate concurrency
+  if (s.concurrency !== undefined) {
+    if (s.concurrency !== 'skip' && s.concurrency !== 'queue') {
+      throw new RoutineValidationError('Schedule "concurrency" must be "skip" or "queue"', { source, got: s.concurrency });
+    }
+  }
+
+  return s as RoutineSchedule;
+}
+
 function validateRoutineDefinition(value: unknown, source?: string): RoutineDefinition {
   if (!value || typeof value !== 'object') {
     throw new RoutineValidationError('Routine must be an object', { source });
@@ -155,6 +252,11 @@ function validateRoutineDefinition(value: unknown, source?: string): RoutineDefi
     throw new RoutineValidationError('Invalid or missing "name"', { source, got: obj.name });
   }
 
+  // Validate schedule if present
+  if (obj.schedule !== undefined) {
+    validateScheduleConfig(obj.schedule, source);
+  }
+
   if (!Array.isArray(obj.steps)) {
     throw new RoutineValidationError('Invalid or missing "steps" (must be an array)', { source });
   }
@@ -255,7 +357,7 @@ function validateRoutineDefinition(value: unknown, source?: string): RoutineDefi
     }
   }
 
-  return obj as RoutineDefinition;
+  return obj as unknown as RoutineDefinition;
 }
 
 function getPath(root: unknown, segments: string[]): unknown {

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 'vitest';
+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!.getUTCMinutes()).toBe(0);
+    expect(nextRun!.getUTCHours()).toBe(11); // Next hour in UTC
+  });
+
+  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);
+  });
+});