@portel/photon 1.23.0 → 1.24.0

package/dist/daemon/server.js

@@ -17,6 +17,8 @@ import * as crypto from 'crypto';
 import { SessionManager } from './session-manager.js';
 import { transferHotReloadState } from './hot-reload-state.js';
 import { resolveWithGlobalFallback } from './session-resolver.js';
+import { loadPersistedSchedulesFromDir } from './schedule-loader.js';
+import { parseCron, computeMissedRun } from './cron.js';
 import { isValidDaemonRequest, } from './protocol.js';
 import { setPromptHandler, setBroker, touchBase, getPhotonSchedulesDir, getPhotonStateLogPath, listActiveBases, pruneBasesRegistry, resolvePhotonPath, } from '@portel/photon-core';
 import { getDefaultContext } from '../context.js';
@@ -435,156 +437,7 @@ staleMapCleanupInterval.unref();
  */
 const scheduledJobs = new Map();
 const jobTimers = new Map();
-function parseCronField(field, min, max) {
-    if (field === '*') {
-        const values = [];
-        for (let i = min; i <= max; i++)
-            values.push(i);
-        return values;
-    }
-    // Comma-separated list
-    if (field.includes(',')) {
-        const values = new Set();
-        for (const part of field.split(',')) {
-            const partValues = parseCronField(part, min, max);
-            if (!partValues)
-                return null;
-            partValues.forEach((v) => values.add(v));
-        }
-        return Array.from(values).sort((a, b) => a - b);
-    }
-    // Step values: */n, start/n, start-end/n
-    if (field.includes('/')) {
-        const slashIdx = field.indexOf('/');
-        const range = field.slice(0, slashIdx);
-        const step = parseInt(field.slice(slashIdx + 1));
-        if (isNaN(step) || step <= 0)
-            return null;
-        let start = min;
-        let end = max;
-        if (range !== '*') {
-            if (range.includes('-')) {
-                const [s, e] = range.split('-').map(Number);
-                if (isNaN(s) || isNaN(e))
-                    return null;
-                start = s;
-                end = e;
-            }
-            else {
-                start = parseInt(range);
-                if (isNaN(start))
-                    return null;
-            }
-        }
-        const values = [];
-        for (let i = start; i <= end; i += step)
-            values.push(i);
-        return values;
-    }
-    // Range: n-m
-    if (field.includes('-')) {
-        const [s, e] = field.split('-').map(Number);
-        if (isNaN(s) || isNaN(e) || s < min || e > max)
-            return null;
-        const values = [];
-        for (let i = s; i <= e; i++)
-            values.push(i);
-        return values;
-    }
-    // Single value
-    const value = parseInt(field);
-    if (isNaN(value) || value < min || value > max)
-        return null;
-    return [value];
-}
-function parseCron(cron) {
-    const parts = cron.trim().split(/\s+/);
-    if (parts.length !== 5) {
-        return { isValid: false, nextRun: 0 };
-    }
-    const [minuteField, hourField, domField, monthField, dowField] = parts;
-    const minutes = parseCronField(minuteField, 0, 59);
-    const hours = parseCronField(hourField, 0, 23);
-    const doms = parseCronField(domField, 1, 31);
-    const months = parseCronField(monthField, 1, 12); // cron months are 1-indexed
-    const dows = parseCronField(dowField, 0, 7); // 0 and 7 both mean Sunday
-    if (!minutes || !hours || !doms || !months || !dows) {
-        return { isValid: false, nextRun: 0 };
-    }
-    const minuteSet = new Set(minutes);
-    const hourSet = new Set(hours);
-    const domSet = new Set(doms);
-    const monthSet = new Set(months);
-    // Normalize: 7 → 0 (both mean Sunday)
-    const dowSet = new Set(dows.map((d) => (d === 7 ? 0 : d)));
-    const domIsWild = domField === '*';
-    const dowIsWild = dowField === '*';
-    // Advance to next minute boundary from now
-    const candidate = new Date();
-    candidate.setSeconds(0);
-    candidate.setMilliseconds(0);
-    candidate.setMinutes(candidate.getMinutes() + 1);
-    const limit = new Date(candidate);
-    limit.setFullYear(limit.getFullYear() + 4);
-    while (candidate < limit) {
-        // Check month (JS: 0-indexed, cron: 1-indexed)
-        if (!monthSet.has(candidate.getMonth() + 1)) {
-            candidate.setMonth(candidate.getMonth() + 1);
-            candidate.setDate(1);
-            candidate.setHours(0);
-            candidate.setMinutes(0);
-            continue;
-        }
-        // Day check: if both dom and dow are non-wild, standard cron uses OR semantics
-        let dayMatch;
-        if (domIsWild && dowIsWild) {
-            dayMatch = true;
-        }
-        else if (domIsWild) {
-            dayMatch = dowSet.has(candidate.getDay());
-        }
-        else if (dowIsWild) {
-            dayMatch = domSet.has(candidate.getDate());
-        }
-        else {
-            dayMatch = domSet.has(candidate.getDate()) || dowSet.has(candidate.getDay());
-        }
-        if (!dayMatch) {
-            candidate.setDate(candidate.getDate() + 1);
-            candidate.setHours(0);
-            candidate.setMinutes(0);
-            continue;
-        }
-        // Check hour
-        if (!hourSet.has(candidate.getHours())) {
-            const nextHour = [...hourSet].find((h) => h > candidate.getHours());
-            if (nextHour !== undefined) {
-                candidate.setHours(nextHour);
-                candidate.setMinutes(0);
-            }
-            else {
-                candidate.setDate(candidate.getDate() + 1);
-                candidate.setHours(0);
-                candidate.setMinutes(0);
-            }
-            continue;
-        }
-        // Check minute
-        if (!minuteSet.has(candidate.getMinutes())) {
-            const nextMinute = [...minuteSet].find((m) => m > candidate.getMinutes());
-            if (nextMinute !== undefined) {
-                candidate.setMinutes(nextMinute);
-            }
-            else {
-                candidate.setHours(candidate.getHours() + 1);
-                candidate.setMinutes(0);
-            }
-            continue;
-        }
-        return { isValid: true, nextRun: candidate.getTime() };
-    }
-    return { isValid: false, nextRun: 0 };
-}
+// parseCron moved to ./cron.ts so the boot loader and tests can reuse it.
 function scheduleJob(job) {
     const { isValid, nextRun } = parseCron(job.cron);
     if (!isValid) {
@@ -619,15 +472,39 @@ async function runJob(jobId) {
     if (!job)
         return;
     const key = compositeKey(job.photonName, job.workingDir);
+    // Phantom prune: when a ScheduleProvider-sourced job's backing file
+    // has been deleted (e.g. `this.schedule.cancel()` ran the unlink
+    // but the in-memory registration survived daemon restart), stop
+    // firing and evict the stale registration. Without this, a cancelled
+    // schedule keeps triggering every interval forever — the main reason
+    // we saw `Cannot run job` logs for jobIds that had no backing file.
+    if (job.sourceFile && !fs.existsSync(job.sourceFile)) {
+        logger.info('Dropping orphan scheduled job — backing file gone', {
+            jobId,
+            photon: job.photonName,
+            sourceFile: job.sourceFile,
+        });
+        unscheduleJob(jobId);
+        return;
+    }
     let sessionManager = sessionManagers.get(key);
-    // Lazy-load: schedules registered proactively at boot carry the photon's
-    // source path on the job, so we can spin up the session when the timer
-    // fires rather than require the photon to be invoked manually first.
-    if (!sessionManager && job.photonPath) {
+    // Lazy-load: if the photon isn't loaded yet (idle-unloaded, or
+    // boot-loaded schedules that predate any CLI invocation), spin up
+    // the session on demand. `getOrCreateSessionManager` falls back to
+    // a disk resolve when `job.photonPath` is absent, so the scheduler
+    // no longer needs the path cached on the job to work — it is purely
+    // an optimisation to skip the disk walk on each fire.
+    if (!sessionManager) {
         try {
             sessionManager =
                 (await getOrCreateSessionManager(job.photonName, job.photonPath, job.workingDir)) ??
                     undefined;
+            // Cache the path we used so subsequent fires skip the resolve.
+            if (sessionManager && !job.photonPath) {
+                const resolved = photonPaths.get(key);
+                if (resolved)
+                    job.photonPath = resolved;
+            }
         }
         catch (err) {
             logger.warn('Lazy-load for scheduled job failed', {
@@ -842,79 +719,47 @@ function deletePersistedIpcSchedule(jobId, photonName) {
  * Process IPC schedule files from one photon's schedules directory.
  * Mutates loadedCount / skippedCount via the returned counters.
  */
-function loadIpcSchedulesFromDir(schedulesPath, ttlMs) {
-    let loaded = 0;
-    let skipped = 0;
-    let files;
-    try {
-        files = fs.readdirSync(schedulesPath).filter((f) => f.endsWith('.json'));
-    }
-    catch {
-        return { loaded, skipped };
-    }
-    for (const file of files) {
-        const filePath = path.join(schedulesPath, file);
-        try {
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const task = JSON.parse(content);
-            // Skip non-IPC jobs (ScheduleProvider handles its own)
-            if (task.source !== 'ipc')
-                continue;
-            // Validate required fields
-            if (!task.id || !task.method || !task.cron || !task.photonName) {
-                logger.warn('Skipping invalid persisted schedule', { file: filePath });
-                skipped++;
-                continue;
+/**
+ * Wire the pure loader from `schedule-loader.ts` to this module's
+ * scheduleJob + scheduledJobs. The loader is kept pure (no daemon
+ * globals, no logger) so tests can import it without triggering the
+ * daemon bootstrap IIFE. See schedule-loader.ts for format details.
+ */
+function loadDaemonSchedulesFromDir(schedulesPath, ttlMs, photonNameHint, workingDirHint) {
+    return loadPersistedSchedulesFromDir(schedulesPath, ttlMs, photonNameHint, workingDirHint, {
+        alreadyRegistered: (id) => scheduledJobs.has(asScheduleKey(id)),
+        register: (job) => {
+            // Seed in-memory lastRun from persisted lastExecutionAt so the post-run
+            // reschedule path keeps updating the same field instead of starting at 0.
+            const scheduledJob = job;
+            if (scheduledJob.lastRun === undefined && job.lastRun !== undefined) {
+                scheduledJob.lastRun = job.lastRun;
             }
-            // TTL check: skip jobs not executed in 30+ days
-            const lastExec = task.lastExecutionAt ? new Date(task.lastExecutionAt).getTime() : 0;
-            const created = task.createdAt ? new Date(task.createdAt).getTime() : 0;
-            const lastActivity = Math.max(lastExec, created);
-            if (lastActivity > 0 && Date.now() - lastActivity > ttlMs) {
-                logger.info('Removing expired schedule (TTL)', {
-                    jobId: task.id,
-                    lastActivity: new Date(lastActivity).toISOString(),
-                });
-                try {
-                    fs.unlinkSync(filePath);
-                }
-                catch {
-                    /* ignore */
+            const ok = scheduleJob(scheduledJob);
+            if (!ok)
+                return false;
+            // If the schedule was supposed to fire while the daemon was down, run
+            // one catch-up for the most recent missed occurrence. We intentionally
+            // fire at most once per boot to avoid a flood after long outages; older
+            // windows are dropped.
+            if (job.lastRun !== undefined) {
+                const missed = computeMissedRun(job.cron, job.lastRun, Date.now());
+                if (missed !== null) {
+                    logger.info('Catch-up fire for missed schedule window', {
+                        jobId: job.id,
+                        photon: job.photonName,
+                        method: job.method,
+                        lastRun: new Date(job.lastRun).toISOString(),
+                        missedAt: new Date(missed).toISOString(),
+                    });
+                    void runJob(asScheduleKey(job.id));
                 }
-                skipped++;
-                continue;
-            }
-            // Skip if already registered (another source may have loaded it)
-            if (scheduledJobs.has(task.id))
-                continue;
-            const job = {
-                id: task.id,
-                method: task.method,
-                args: task.args || {},
-                cron: task.cron,
-                runCount: task.executionCount || 0,
-                createdAt: created || Date.now(),
-                createdBy: task.createdBy,
-                photonName: task.photonName,
-                workingDir: task.workingDir,
-            };
-            if (scheduleJob(job)) {
-                loaded++;
-            }
-            else {
-                logger.warn('Failed to schedule persisted job (invalid cron?)', { jobId: task.id });
-                skipped++;
             }
-        }
-        catch (err) {
-            logger.warn('Failed to load persisted schedule file', {
-                file: filePath,
-                error: getErrorMessage(err),
-            });
-            skipped++;
-        }
-    }
-    return { loaded, skipped };
+            return true;
+        },
+        warn: (msg, ctx) => logger.warn(msg, ctx),
+        info: (msg, ctx) => logger.info(msg, ctx),
+    });
 }
 /**
  * One-time sweep of legacy IPC schedules from ~/.photon/schedules/ to the
@@ -1027,7 +872,9 @@ function loadAllPersistedSchedules() {
             if (scannedDirs.has(schedulesPath))
                 continue;
             scannedDirs.add(schedulesPath);
-            const result = loadIpcSchedulesFromDir(schedulesPath, ttlMs);
+            // Legacy flat root: {root}/<photonName>/*.json — photon name IS
+            // the directory name.
+            const result = loadDaemonSchedulesFromDir(schedulesPath, ttlMs, dir.name, undefined);
             loadedCount += result.loaded;
             skippedCount += result.skipped;
         }
@@ -1060,7 +907,10 @@ function loadAllPersistedSchedules() {
             if (scannedDirs.has(schedulesPath))
                 continue;
             scannedDirs.add(schedulesPath);
-            const result = loadIpcSchedulesFromDir(schedulesPath, ttlMs);
+            // Per-base layout: {baseDir}/.data/<photonName>/schedules/*.json.
+            // Photon name is the entry name, working dir is the base itself
+            // (used for session resolution when the cron fires).
+            const result = loadDaemonSchedulesFromDir(schedulesPath, ttlMs, entry.name, baseDir);
             loadedCount += result.loaded;
             skippedCount += result.skipped;
         }