@goodandready/dsh-cron 0.2.34 → 0.2.35

package/lib/api.js

@@ -218,7 +218,13 @@ async function createOrUpdateTask({ store, scheduler, req, res, apiToken }) {
       return;
     }
   }
-  const task = store.set(buildTaskRecord(store, body, taskType, parsed));
+  let task;
+  try {
+    task = store.set(buildTaskRecord(store, body, taskType, parsed));
+  } catch (err) {
+    sendJson(res, 500, { ok: false, error: 'Failed to persist task: ' + err.message });
+    return;
+  }
   if (task.status === 'active') {
     scheduler.scheduleTask(task);
   } else {
@@ -345,7 +351,12 @@ async function handleItemPost({ store, scheduler, req, res, url, id, action }) {
       return true;
     }
     const copy = buildDuplicateTask(source, { id: randomUUID() });
-    store.set(copy);
+    try {
+      store.set(copy);
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: 'Failed to persist duplicate task: ' + err.message });
+      return true;
+    }
     // A copy starts paused: it must never fire on its own before the user
     // reviews the schedule (a duplicated one-shot may point at a past time).
     scheduler.pauseTask(copy.id);
@@ -402,7 +413,7 @@ async function patchTask({ store, scheduler, req, res, id }) {
     allowCodeSwitch: req.headers[SCRIPT_CONFIRM_HEADER] === 'script',
   });
   if (!result.ok) {
-    const status = result.notFound ? 404 : (result.needsConfirmation ? 403 : 400);
+    const status = result.status || (result.notFound ? 404 : (result.needsConfirmation ? 403 : 400));
     const error = result.needsConfirmation
       ? `Switching a task to the ${normalizeTaskType(body.type)} type over HTTP requires the ${SCRIPT_CONFIRM_HEADER}: script header`
       : result.error;
@@ -428,7 +439,12 @@ function deleteTask({ store, scheduler, res, id }) {
     } else if (scheduler) {
       scheduler.pauseTask(id);
     }
-    store.delete(id);
+    try {
+      store.delete(id);
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: 'Failed to delete task: ' + err.message });
+      return;
+    }
   }
   sendJson(res, 200, { ok: true });
 }

package/lib/index.js

@@ -198,6 +198,7 @@ export function apply(ctx, rawConfig) {
     return () => {
       if (heartbeatTimer) clearInterval(heartbeatTimer);
       scheduler.stopAll();
+      bestEffort('lifecycle-store-flush', () => store.flushSync(), logger);
     };
   }, 'dsh-cron: lifecycle');
 

package/lib/scheduler-execution.js

@@ -142,6 +142,7 @@ export async function executeWithFallback(scheduler, task, signal, options = {})
  * Begin a task run with concurrency and overlap policy checks.
  */
 export function beginRun(scheduler, task, taskId) {
+  if (scheduler.isStopped) return null;
   if (!scheduler.running.has(taskId) && scheduler.maxConcurrent > 0 && scheduler.running.size >= scheduler.maxConcurrent) {
     if (task.overlapPolicy === 'queue') {
       logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) queued by concurrency limit (${scheduler.maxConcurrent})`);
@@ -174,7 +175,8 @@ export function beginRun(scheduler, task, taskId) {
   }
 
   const controller = new AbortController();
-  const currentRun = { controller, startedAt: Date.now(), queueCount: 0 };
+  const runId = 'run_' + Math.random().toString(36).slice(2, 9) + '_' + Date.now();
+  const currentRun = { id: runId, controller, startedAt: Date.now(), queueCount: 0 };
   scheduler.running.set(taskId, currentRun);
   return currentRun;
 }
@@ -183,6 +185,7 @@ export function beginRun(scheduler, task, taskId) {
  * Run task by ID.
  */
 export async function executeTask(scheduler, taskId, options = {}) {
+  if (scheduler.isStopped) return null;
   const task = scheduler.store.get(taskId);
   if (!task) return null;
 
@@ -328,19 +331,32 @@ export async function deliverNotifications(task, runInfo, { store, resolveSecret
 /**
  * Post-run bookkeeping: one-shot completion, next-run timestamp, retry backoff, draining.
  */
-export function finishRun(scheduler, task, taskId, status, queuedCount) {
+export function finishRun(scheduler, taskSnapshot, taskId, status, queuedCount, meta = {}) {
   scheduler.countRun(status);
+
+  // If this run was superseded by a newer run or scheduler is stopped, skip updating task
+  if (meta.isCurrentRun === false || scheduler.isStopped) {
+    return;
+  }
+
+  // Refetch live task from store to avoid resurrecting deleted task or overwriting edits (#215)
+  const current = scheduler.store.get(taskId);
+  if (!current) {
+    logger.info(`[dsh-cron] finishRun: task "${taskId}" no longer exists in store; skipping completion write`);
+    return;
+  }
+
   try {
-    if (task.oneShot) {
-      task.status = 'completed';
-      task.nextRunAt = null;
-      scheduler.store.set(task);
+    if (current.oneShot) {
+      current.status = 'completed';
+      current.nextRunAt = null;
+      scheduler.store.set(current);
     } else {
       const job = scheduler.jobs.get(taskId);
       if (job) {
         const next = job.nextRun();
-        task.nextRunAt = next ? next.getTime() : null;
-        scheduler.store.set(task);
+        current.nextRunAt = next ? next.getTime() : null;
+        scheduler.store.set(current);
       }
     }
   } catch (err) {
@@ -349,32 +365,36 @@ export function finishRun(scheduler, task, taskId, status, queuedCount) {
 
   try {
     const failed = status === 'error' || status === 'timeout';
-    const maxRetries = Number(task.maxRetries) > 0 ? Number(task.maxRetries) : 0;
-    if (failed && maxRetries > 0 && (task.attempts || 0) < maxRetries && task.status !== 'paused') {
-      task.attempts = (task.attempts || 0) + 1;
-      const backoffMs = (Number(task.retryBackoffMs) > 0 ? Number(task.retryBackoffMs) : 30000) * Math.pow(2, task.attempts - 1);
-      const attempt = task.attempts;
-      scheduler.store.set(task);
+    const maxRetries = Number(current.maxRetries) > 0 ? Number(current.maxRetries) : 0;
+    if (failed && maxRetries > 0 && (current.attempts || 0) < maxRetries && current.status !== 'paused' && !scheduler.isStopped) {
+      current.attempts = (current.attempts || 0) + 1;
+      const backoffMs = (Number(current.retryBackoffMs) > 0 ? Number(current.retryBackoffMs) : 30000) * Math.pow(2, current.attempts - 1);
+      const attempt = current.attempts;
+      scheduler.store.set(current);
       scheduler.clearRetryTimer(taskId);
       scheduler.retryTimers.set(taskId, setTimeout(() => {
         scheduler.retryTimers.delete(taskId);
-        scheduler.runTask(taskId, { isRetry: true });
+        if (!scheduler.isStopped) {
+          scheduler.runTask(taskId, { isRetry: true });
+        }
       }, backoffMs));
-      logger.info(`[dsh-cron] retry ${attempt}/${maxRetries} for task "${task.title}" in ${backoffMs}ms`);
-    } else if (!failed && task.attempts) {
-      task.attempts = 0;
-      scheduler.store.set(task);
-    } else if (failed && maxRetries > 0 && (task.attempts || 0) >= maxRetries) {
-      task.attempts = 0;
-      scheduler.store.set(task);
+      logger.info(`[dsh-cron] retry ${attempt}/${maxRetries} for task "${current.title}" in ${backoffMs}ms`);
+    } else if (!failed && current.attempts) {
+      current.attempts = 0;
+      scheduler.store.set(current);
+    } else if (failed && maxRetries > 0 && (current.attempts || 0) >= maxRetries) {
+      current.attempts = 0;
+      scheduler.store.set(current);
     }
   } catch (err) {
     logger.error('[dsh-cron] retry bookkeeping failed for task', taskId + ':', err.message);
   }
 
-  if (queuedCount > 0) {
+  if (queuedCount > 0 && !scheduler.isStopped) {
     setImmediate(() => {
-      scheduler.runTask(taskId);
+      if (!scheduler.isStopped) {
+        scheduler.runTask(taskId);
+      }
     });
   }
 }
@@ -440,24 +460,29 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
   }
 
   const finishedRun = scheduler.running.get(taskId);
-  if (finishedRun === currentRun) scheduler.running.delete(taskId);
-  const queuedCount = finishedRun?.queueCount || 0;
+  const isCurrentRun = (finishedRun === currentRun);
+  if (isCurrentRun) scheduler.running.delete(taskId);
+  const queuedCount = isCurrentRun ? (finishedRun?.queueCount || 0) : 0;
 
   if (!silent.skipped) await scheduler.deliverNotifications(task, runInfo);
-  scheduler.finishRun(task, taskId, outcome.status, queuedCount);
+  scheduler.finishRun(task, taskId, outcome.status, queuedCount, { isCurrentRun, runId: currentRun?.id });
+
+  if (scheduler.isStopped) return;
 
   const guard = await checkAndApplyBurnGuard(scheduler, taskId, outcome);
   if (guard && guard.exceeded) return;
 
-  while (scheduler.queue.length > 0 && scheduler.running.size < scheduler.maxConcurrent) {
+  while (!scheduler.isStopped && scheduler.queue.length > 0 && scheduler.running.size < scheduler.maxConcurrent) {
     const nextItem = scheduler.queue.shift();
     if (!nextItem) break;
     const queuedTask = scheduler.store.get(nextItem.taskId);
-    if (queuedTask && queuedTask.status === 'active') {
+    if (queuedTask && queuedTask.status === 'active' && !scheduler.isStopped) {
       setImmediate(() => {
-        scheduler.runTask(nextItem.taskId).catch((runErr) => {
-          bestEffort('drain-queued-task', () => {}, scheduler.logger);
-        });
+        if (!scheduler.isStopped) {
+          scheduler.runTask(nextItem.taskId).catch((runErr) => {
+            bestEffort('drain-queued-task', () => {}, scheduler.logger);
+          });
+        }
       });
       break;
     }

package/lib/scheduler.js

@@ -254,6 +254,8 @@ export class TaskScheduler {
     this.queue = [];
     this.heartbeatTimer = null;
     this.logger = opts.logger || null;
+    this.isStopped = false;
+    this.generation = 0;
   }
 
   isRunning(taskId) {
@@ -290,6 +292,8 @@ export class TaskScheduler {
   }
 
   start() {
+    this.isStopped = false;
+    this.generation = (this.generation || 0) + 1;
     const tasks = this.store.list();
     const now = Date.now();
     for (const task of tasks) {
@@ -328,7 +332,13 @@ export class TaskScheduler {
   }
 
   stopAll() {
+    this.isStopped = true;
+    this.generation = (this.generation || 0) + 1;
     this.stopHeartbeatWatcher();
+
+    // Clear concurrency queue (#217)
+    this.queue = [];
+
     for (const [, job] of this.jobs.entries()) {
       bestEffort('stop-job', () => job.stop(), this.logger);
     }
@@ -348,6 +358,10 @@ export class TaskScheduler {
       bestEffort('abort-running', () => run.controller.abort(new Error('Scheduler stopped')), this.logger);
     }
     this.running.clear();
+
+    if (this.store && typeof this.store.flushSync === 'function') {
+      bestEffort('store-flush-on-stop', () => this.store.flushSync(), this.logger);
+    }
   }
 
   clearScheduled(taskId) {
@@ -451,6 +465,7 @@ export class TaskScheduler {
   }
 
   async runTask(taskId, options = {}) {
+    if (this.isStopped) return null;
     return executeTask(this, taskId, options);
   }
 
@@ -500,8 +515,8 @@ export class TaskScheduler {
     });
   }
 
-  finishRun(task, taskId, status, queuedCount) {
-    return finishRun(this, task, taskId, status, queuedCount);
+  finishRun(task, taskId, status, queuedCount, meta) {
+    return finishRun(this, task, taskId, status, queuedCount, meta);
   }
 
   pauseTask(taskId, reason) {

package/lib/store.js

@@ -112,7 +112,11 @@ export class TaskStore {
     if (this._saveTimer) return;
     this._saveTimer = setTimeout(() => {
       this._saveTimer = null;
-      this.save();
+      try {
+        this.save();
+      } catch (err) {
+        logger.error('[dsh-cron] debounced save failed:', err.message);
+      }
     }, delay);
     if (typeof this._saveTimer.unref === 'function') {
       this._saveTimer.unref();
@@ -160,6 +164,7 @@ export class TaskStore {
       }
     } catch (err) {
       logger.error('[dsh-cron] store save error:', err.message);
+      throw err;
     }
   }
 
@@ -254,6 +259,7 @@ export class TaskStore {
       else if (typeof value === 'string') patch[key] = value.trim();
     }
 
+    const prevSettings = this.settings;
     this.settings = {
       ...this.settings,
       ...patch,
@@ -265,7 +271,12 @@ export class TaskStore {
       onlyOnFailure: patch.onlyOnFailure !== undefined ? Boolean(patch.onlyOnFailure) : Boolean(this.settings.onlyOnFailure),
       llmActionsEnabled: patch.llmActionsEnabled !== undefined ? Boolean(patch.llmActionsEnabled) : Boolean(this.settings.llmActionsEnabled),
     };
-    this.save();
+    try {
+      this.save();
+    } catch (err) {
+      this.settings = prevSettings;
+      throw err;
+    }
     return this.getSettings();
   }
 
@@ -292,7 +303,8 @@ export class TaskStore {
   set(task) {
     const now = Date.now();
     const id = task.id || ('cron_' + Math.random().toString(36).slice(2, 9));
-    const prev = this.tasks.get(id) || {};
+    const existing = this.tasks.get(id);
+    const prev = existing || {};
     const record = {
       ...prev,
       ...task,
@@ -337,7 +349,13 @@ export class TaskStore {
       nextRunAt: task.nextRunAt !== undefined ? task.nextRunAt : (prev.nextRunAt || null),
     };
     this.tasks.set(id, record);
-    this.save();
+    try {
+      this.save();
+    } catch (err) {
+      if (existing) this.tasks.set(id, existing);
+      else this.tasks.delete(id);
+      throw err;
+    }
     return record;
   }
 
@@ -345,13 +363,25 @@ export class TaskStore {
     const task = this.tasks.get(id);
     if (!task) return null;
     const now = Date.now();
+    const prevPing = task.lastPingAt;
+    const prevAlerted = task.heartbeatAlerted;
+    const prevUpdated = task.updatedAt;
+    const prevStatus = task.lastStatus;
     task.lastPingAt = now;
     task.heartbeatAlerted = false;
     task.updatedAt = now;
     if (task.lastStatus === 'missed') {
       task.lastStatus = 'active';
     }
-    this.save();
+    try {
+      this.save();
+    } catch (err) {
+      task.lastPingAt = prevPing;
+      task.heartbeatAlerted = prevAlerted;
+      task.updatedAt = prevUpdated;
+      task.lastStatus = prevStatus;
+      throw err;
+    }
     const interval = (task.heartbeatIntervalSeconds || 0) + (task.gracePeriodSeconds || 300);
     return {
       ok: true,
@@ -363,10 +393,19 @@ export class TaskStore {
   }
 
   delete(id) {
-    const existed = this.tasks.delete(id);
+    const existing = this.tasks.get(id);
+    if (!existing) return false;
+    const existingHistory = this.history.get(id);
+    this.tasks.delete(id);
     this.history.delete(id);
-    if (existed) this.save();
-    return existed;
+    try {
+      this.save();
+    } catch (err) {
+      this.tasks.set(id, existing);
+      if (existingHistory) this.history.set(id, existingHistory);
+      throw err;
+    }
+    return true;
   }
 
   recordRun(id, runInfo) {

package/lib/task-patch.js

@@ -114,10 +114,14 @@ export function applyTaskPatch({ store, scheduler, id, body, allowCodeSwitch = f
   }
   const built = buildTaskPatch(current, body);
   if (!built.ok) return built;
-  const task = store.set({ ...current, ...built.patch, id });
-  if (task.status === 'active') scheduler.scheduleTask(task);
-  else scheduler.pauseTask(id);
-  return { ok: true, task, patch: built.patch };
+  try {
+    const task = store.set({ ...current, ...built.patch, id });
+    if (task.status === 'active') scheduler.scheduleTask(task);
+    else scheduler.pauseTask(id);
+    return { ok: true, task, patch: built.patch };
+  } catch (err) {
+    return { ok: false, error: 'Failed to persist task patch: ' + err.message, status: 500 };
+  }
 }
 
 /** Human-readable summary of what changed, for tool output and logs. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.2.34",
+  "version": "0.2.35",
   "description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
   "type": "module",
   "main": "lib/index.js",