jm2 0.1.10 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jm2",
-  "version": "0.1.10",
+  "version": "0.1.13",
   "description": "Job Manager 2 - A simple yet powerful job scheduler combining cron and at functionality",
   "type": "module",
   "main": "src/cli/index.js",

package/src/core/service.js

@@ -178,8 +178,6 @@ class DarwinService extends PlatformService {
     </array>
     <key>RunAtLoad</key>
     <true/>
-    <key>KeepAlive</key>
-    <true/>
     <key>StandardOutPath</key>
     <string>${stdoutPath}</string>
     <key>StandardErrorPath</key>
@@ -344,8 +342,6 @@ Type=forking
 ExecStart=${nodePath} ${jm2Path} start
 ExecStop=${nodePath} ${jm2Path} stop
 ExecReload=${nodePath} ${jm2Path} restart
-Restart=always
-RestartSec=10
 Environment="JM2_DATA_DIR=${dataDir}"
 StandardOutput=append:${join(logDir, 'service-out.log')}
 StandardError=append:${join(logDir, 'service-err.log')}

package/src/daemon/scheduler.js

@@ -193,9 +193,38 @@ export class Scheduler {
     return nextRun;
   }
 
+  /**
+   * Find periodic jobs that are overdue (nextRun is in the past)
+   * This handles system sleep/wake scenarios where jobs should have run while asleep
+   * @param {Date} now - Current time
+   * @returns {Array} Array of overdue job IDs
+   */
+  findOverduePeriodicJobs(now) {
+    const overdueJobs = [];
+
+    for (const [id, job] of this.jobs) {
+      if (
+        job.status === JobStatus.ACTIVE &&
+        job.type === JobType.CRON &&
+        job.cron &&
+        job.nextRun
+      ) {
+        const timeSinceNextRun = now.getTime() - job.nextRun.getTime();
+        const isOverdue = timeSinceNextRun > this.checkIntervalMs * 2;
+
+        if (isOverdue) {
+          overdueJobs.push(id);
+        }
+      }
+    }
+
+    return overdueJobs;
+  }
+
   /**
    * Recalculate next run times for periodic jobs that have drifted into the past
    * This handles system sleep/wake scenarios where nextRun becomes stale
+   * Only recalculates jobs that are significantly overdue (missed multiple runs)
    * @param {Date} now - Current time
    */
   recalculateStalePeriodicJobs(now) {
@@ -204,17 +233,21 @@ export class Scheduler {
         job.status === JobStatus.ACTIVE &&
         job.type === JobType.CRON &&
         job.cron &&
-        job.nextRun &&
-        job.nextRun < now
+        job.nextRun
       ) {
-        // Job's next run is in the past - recalculate from now to find next future occurrence
-        const newNextRun = this.calculateNextRun(job, now);
-        if (newNextRun && newNextRun !== job.nextRun) {
-          this.logger.debug(
-            `Recalculating next run for job ${id} (${job.name || 'unnamed'}): ` +
-            `${job.nextRun.toISOString()} → ${newNextRun.toISOString()}`
-          );
-          this.updateJobNextRun(id, newNextRun);
+        const timeSinceNextRun = now.getTime() - job.nextRun.getTime();
+        const isSignificantlyOverdue = timeSinceNextRun > this.checkIntervalMs * 2;
+
+        if (isSignificantlyOverdue) {
+          // Job is significantly overdue - recalculate from now to find next future occurrence
+          const newNextRun = this.calculateNextRun(job, now);
+          if (newNextRun && newNextRun !== job.nextRun) {
+            this.logger.debug(
+              `Recalculating next run for job ${id} (${job.name || 'unnamed'}): ` +
+              `${job.nextRun.toISOString()} → ${newNextRun.toISOString()}`
+            );
+            this.updateJobNextRun(id, newNextRun);
+          }
         }
       }
     }
@@ -316,8 +349,26 @@ export class Scheduler {
 
     const nowDate = new Date();
 
-    // Recalculate next run for periodic jobs that have drifted into the past
-    // This handles system sleep/wake scenarios
+    // Check for overdue jobs BEFORE recalculating next run times
+    // This ensures jobs that should have run while system was asleep get executed
+    const overdueJobIds = this.findOverduePeriodicJobs(nowDate);
+    if (overdueJobIds.length > 0) {
+      this.logger.info(`Found ${overdueJobIds.length} overdue job(s) to execute after system wake`);
+      for (const jobId of overdueJobIds) {
+        const job = this.jobs.get(jobId);
+        if (job) {
+          this.logger.info(`Executing overdue job ${jobId} (${job.name || 'unnamed'})`);
+          // Execute immediately without waiting for the normal due jobs check
+          this.executeJob(job);
+          // Update next run time from now for the next scheduled occurrence
+          const nextRun = this.calculateNextRun(job, nowDate);
+          this.updateJobNextRun(jobId, nextRun);
+        }
+      }
+    }
+
+    // Recalculate next run for any remaining periodic jobs that have drifted into the past
+    // This handles edge cases and ensures nextRun times are in the future
     this.recalculateStalePeriodicJobs(nowDate);
 
     const dueJobs = this.getDueJobs();