@rebasepro/server-core 0.0.1-canary.94dff14 → 0.0.1-canary.bbcb8b4

package/dist/index.es.js

@@ -49220,46 +49220,98 @@ const cronLoader = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   __proto__: null,
   loadCronJobsFromDirectory
 }, Symbol.toStringTag, { value: "Module" }));
+function expandCronField(field, min, max) {
+  const results = /* @__PURE__ */ new Set();
+  for (const segment of field.split(",")) {
+    const trimmed = segment.trim();
+    if (trimmed === "*") {
+      for (let i = min; i <= max; i++) results.add(i);
+    } else if (trimmed.includes("/")) {
+      const [rangeStr, stepStr] = trimmed.split("/");
+      const step = parseInt(stepStr, 10);
+      if (isNaN(step) || step <= 0) {
+        throw new Error(`Invalid step value "${stepStr}" in cron field "${field}"`);
+      }
+      let start = min;
+      let end2 = max;
+      if (rangeStr !== "*") {
+        if (rangeStr.includes("-")) {
+          const [a2, b] = rangeStr.split("-").map(Number);
+          start = a2;
+          end2 = b;
+        } else {
+          start = parseInt(rangeStr, 10);
+        }
+      }
+      for (let i = start; i <= end2; i += step) results.add(i);
+    } else if (trimmed.includes("-")) {
+      const [a2, b] = trimmed.split("-").map(Number);
+      for (let i = a2; i <= b; i++) results.add(i);
+    } else {
+      const val = parseInt(trimmed, 10);
+      if (isNaN(val)) {
+        throw new Error(`Invalid value "${trimmed}" in cron field "${field}"`);
+      }
+      results.add(val);
+    }
+  }
+  return [...results].sort((a2, b) => a2 - b);
+}
+function validateCronExpression(schedule) {
+  if (!schedule || typeof schedule !== "string") {
+    return {
+      valid: false,
+      reason: "Schedule must be a non-empty string"
+    };
+  }
+  const parts = schedule.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    return {
+      valid: false,
+      reason: `Expected 5 fields, got ${parts.length}`
+    };
+  }
+  const fieldRanges = [["minute", 0, 59], ["hour", 0, 23], ["day of month", 1, 31], ["month", 1, 12], ["day of week", 0, 6]];
+  for (let i = 0; i < 5; i++) {
+    const [name2, min, max] = fieldRanges[i];
+    try {
+      const values2 = expandCronField(parts[i], min, max);
+      if (values2.length === 0) {
+        return {
+          valid: false,
+          reason: `${name2} field "${parts[i]}" produces no values`
+        };
+      }
+      for (const v of values2) {
+        if (v < min || v > max) {
+          return {
+            valid: false,
+            reason: `${name2} field value ${v} out of range [${min}–${max}]`
+          };
+        }
+      }
+    } catch (err) {
+      return {
+        valid: false,
+        reason: `${name2} field: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  return {
+    valid: true
+  };
+}
 function parseCronExpression(expression, after) {
   const parts = expression.trim().split(/\s+/);
   if (parts.length < 5) {
     throw new Error(`Invalid cron expression: "${expression}". Expected 5 fields.`);
   }
   const [minField, hourField, domField, monField, dowField] = parts;
-  const expand = (field, min, max) => {
-    const results = /* @__PURE__ */ new Set();
-    for (const segment of field.split(",")) {
-      if (segment === "*") {
-        for (let i = min; i <= max; i++) results.add(i);
-      } else if (segment.includes("/")) {
-        const [rangeStr, stepStr] = segment.split("/");
-        const step = parseInt(stepStr, 10);
-        let start = min;
-        let end2 = max;
-        if (rangeStr !== "*") {
-          if (rangeStr.includes("-")) {
-            const [a2, b] = rangeStr.split("-").map(Number);
-            start = a2;
-            end2 = b;
-          } else {
-            start = parseInt(rangeStr, 10);
-          }
-        }
-        for (let i = start; i <= end2; i += step) results.add(i);
-      } else if (segment.includes("-")) {
-        const [a2, b] = segment.split("-").map(Number);
-        for (let i = a2; i <= b; i++) results.add(i);
-      } else {
-        results.add(parseInt(segment, 10));
-      }
-    }
-    return [...results].sort((a2, b) => a2 - b);
-  };
-  const minutes = expand(minField, 0, 59);
-  const hours = expand(hourField, 0, 23);
-  const doms = expand(domField, 1, 31);
-  const months = expand(monField, 1, 12);
-  const dows = expand(dowField, 0, 6);
+  const minutes = expandCronField(minField, 0, 59);
+  const hours = expandCronField(hourField, 0, 23);
+  const doms = expandCronField(domField, 1, 31);
+  const months = expandCronField(monField, 1, 12);
+  const dows = expandCronField(dowField, 0, 6);
   const candidate = new Date(after);
   candidate.setSeconds(0, 0);
   candidate.setMinutes(candidate.getMinutes() + 1);
@@ -49280,6 +49332,7 @@ function parseCronExpression(expression, after) {
   return fallback;
 }
 const MAX_LOGS_PER_JOB = 50;
+const MIN_SCHEDULE_INTERVAL_MS = 5e3;
 class CronScheduler {
   jobs = /* @__PURE__ */ new Map();
   started = false;
@@ -49301,23 +49354,39 @@ class CronScheduler {
   }
   /**
    * Register a batch of loaded cron jobs.
+   *
+   * If the scheduler is already started, newly registered jobs are
+   * automatically scheduled (so late-registered jobs don't sit idle).
+   *
+   * Validates the cron schedule on registration — invalid schedules
+   * are rejected with a warning and the job is NOT registered.
    */
   registerJobs(loadedJobs) {
     for (const loaded of loadedJobs) {
+      const validation = validateCronExpression(loaded.definition.schedule);
+      if (!validation.valid) {
+        console.error(`[cron] Rejecting job "${loaded.id}": invalid schedule "${loaded.definition.schedule}" — ${validation.reason}`);
+        continue;
+      }
       const existing = this.jobs.get(loaded.id);
       if (existing) {
         console.warn(`[cron] Duplicate cron job id: "${loaded.id}". Overwriting.`);
         this.stopJob(loaded.id);
       }
+      const enabled = loaded.definition.enabled !== false;
       this.jobs.set(loaded.id, {
         id: loaded.id,
         definition: loaded.definition,
-        enabled: loaded.definition.enabled !== false,
-        state: loaded.definition.enabled !== false ? "idle" : "disabled",
+        enabled,
+        state: enabled ? "idle" : "disabled",
         totalRuns: 0,
         totalFailures: 0,
-        logs: []
+        logs: [],
+        executing: false
       });
+      if (this.started && enabled) {
+        this.scheduleNext(loaded.id);
+      }
     }
   }
   /**
@@ -49351,6 +49420,9 @@ class CronScheduler {
   }
   /**
    * Stop the scheduler and clear all timers.
+   *
+   * Currently-executing handlers run to completion (they are async),
+   * but no further scheduling occurs after stop.
    */
   stop() {
     this.started = false;
@@ -49409,32 +49481,81 @@ class CronScheduler {
   }
   /**
    * Manually trigger a job execution immediately.
+   *
+   * Returns `undefined` if the job doesn't exist.
+   * If the job is currently executing, returns the log entry with
+   * a `skipped: true` result rather than running concurrently.
    */
   async triggerJob(id) {
     const job = this.jobs.get(id);
     if (!job) return void 0;
+    if (job.executing) {
+      console.warn(`[cron] Skipping manual trigger of "${id}" — already executing`);
+      const logEntry = {
+        jobId: id,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: 0,
+        success: true,
+        result: {
+          skipped: true,
+          reason: "already_executing"
+        },
+        logs: ["Skipped: job is already running"],
+        manual: true
+      };
+      job.logs.push(logEntry);
+      if (job.logs.length > MAX_LOGS_PER_JOB) job.logs.shift();
+      return logEntry;
+    }
     return this.executeJob(job, true);
   }
   // ─── Internal ────────────────────────────────────────────────────
+  /**
+   * Schedule the next execution for a job.
+   *
+   * Safety guarantees:
+   * 1. Clears any existing timer first (prevents leaked/duplicate timers)
+   * 2. Enforces a minimum delay to prevent tight loops from jitter
+   * 3. Unref's the timer so it doesn't prevent process exit
+   * 4. Re-checks enabled & started state before executing
+   * 5. Concurrency guard prevents overlapping handler executions
+   */
   scheduleNext(id) {
     const job = this.jobs.get(id);
     if (!job || !job.enabled || !this.started) return;
+    this.stopJob(id);
     try {
       const now = /* @__PURE__ */ new Date();
       const nextRun = parseCronExpression(job.definition.schedule, now);
       job.nextRunAt = nextRun;
-      const delay = Math.max(nextRun.getTime() - now.getTime(), 0);
-      job.timerId = setTimeout(async () => {
+      const rawDelay = nextRun.getTime() - now.getTime();
+      const delay = Math.max(rawDelay, MIN_SCHEDULE_INTERVAL_MS);
+      const timer = setTimeout(async () => {
         if (!job.enabled || !this.started) return;
+        if (job.executing) {
+          console.warn(`[cron] Skipping scheduled run of "${id}" — still executing from previous run`);
+          this.scheduleNext(id);
+          return;
+        }
         await this.executeJob(job, false);
-        this.scheduleNext(id);
+        if (this.started && job.enabled) {
+          this.scheduleNext(id);
+        }
       }, delay);
+      if (timer && typeof timer === "object" && "unref" in timer) {
+        timer.unref();
+      }
+      job.timerId = timer;
     } catch (err) {
       console.error(`[cron] Failed to schedule "${id}":`, err);
       job.state = "error";
       job.lastError = err instanceof Error ? err.message : String(err);
     }
   }
+  /**
+   * Stop a single job's timer and clear its next run state.
+   */
   stopJob(id) {
     const job = this.jobs.get(id);
     if (job?.timerId) {
@@ -49443,9 +49564,19 @@ class CronScheduler {
       job.nextRunAt = void 0;
     }
   }
+  /**
+   * Execute a job's handler with full isolation and safety.
+   *
+   * - Sets a concurrency flag to prevent overlapping runs
+   * - Wraps handler in a timeout race
+   * - Captures all logs, errors, and results
+   * - Persists to store (non-blocking) if available
+   * - Always restores state even on catastrophic errors
+   */
   async executeJob(job, manual) {
     const startedAt = /* @__PURE__ */ new Date();
     const capturedLogs = [];
+    job.executing = true;
     const ctx = {
       jobId: job.id,
       scheduledAt: startedAt,
@@ -49464,14 +49595,21 @@ class CronScheduler {
     try {
       const timeout = (job.definition.timeoutSeconds ?? 300) * 1e3;
       const handlerPromise = Promise.resolve(job.definition.handler(ctx));
+      let timeoutHandle;
       const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => reject(new Error(`Cron job "${job.id}" timed out after ${timeout}ms`)), timeout);
+        timeoutHandle = setTimeout(() => reject(new Error(`Cron job "${job.id}" timed out after ${timeout}ms`)), timeout);
       });
-      result = await Promise.race([handlerPromise, timeoutPromise]);
+      try {
+        result = await Promise.race([handlerPromise, timeoutPromise]);
+      } finally {
+        clearTimeout(timeoutHandle);
+      }
     } catch (err) {
       success = false;
       error2 = err instanceof Error ? err.message : String(err);
       job.totalFailures++;
+    } finally {
+      job.executing = false;
     }
     const finishedAt = /* @__PURE__ */ new Date();
     const durationMs = finishedAt.getTime() - startedAt.getTime();
@@ -49494,8 +49632,8 @@ class CronScheduler {
       job.logs.shift();
     }
     if (this.store) {
-      this.store.insertLog(logEntry).catch((err) => {
-        console.error(`[cron] Failed to persist log for "${job.id}":`, err);
+      this.store.insertLog(logEntry).catch((persistErr) => {
+        console.error(`[cron] Failed to persist log for "${job.id}":`, persistErr);
       });
     }
     if (success) {
@@ -49524,7 +49662,8 @@ class CronScheduler {
 }
 const cronScheduler = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  CronScheduler
+  CronScheduler,
+  validateCronExpression
 }, Symbol.toStringTag, { value: "Module" }));
 function createCronRoutes(scheduler) {
   const router = new Hono();
@@ -49927,6 +50066,7 @@ export {
   resetConsole,
   serveSPA,
   strictAuthLimiter,
+  validateCronExpression,
   validatePasswordStrength,
   verifyAccessToken,
   verifyPassword