@goodandready/dsh-cron 0.2.28 → 0.2.30

package/lib/scheduler-execution.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import { checkAndApplyBurnGuard, checkTaskBudgetLimits } from './burn-guard.js';
 import { resolveTaskForExecution } from './prompt-interpolation.js';
 import { bestEffort } from './best-effort.js';
@@ -126,7 +127,7 @@ export async function executeWithFallback(scheduler, task, signal, options = {})
     provider: task.fallbackProvider || task.provider,
     model: task.fallbackModel,
   };
-  console.log(`[dsh-cron] task "${task.title}" failed on ${task.model || 'the default model'}, retrying once on ${task.fallbackModel}`);
+  logger.info(`[dsh-cron] task "${task.title}" failed on ${task.model || 'the default model'}, retrying once on ${task.fallbackModel}`);
   const secondary = await scheduler.executeOnce(fallbackTask, signal, options);
   return {
     ...secondary,
@@ -143,12 +144,12 @@ export async function executeWithFallback(scheduler, task, signal, options = {})
 export function beginRun(scheduler, task, taskId) {
   if (!scheduler.running.has(taskId) && scheduler.maxConcurrent > 0 && scheduler.running.size >= scheduler.maxConcurrent) {
     if (task.overlapPolicy === 'queue') {
-      console.log(`[dsh-cron] Task "${task.title}" (${taskId}) queued by concurrency limit (${scheduler.maxConcurrent})`);
+      logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) queued by concurrency limit (${scheduler.maxConcurrent})`);
       scheduler.queue.push({ taskId, priority: task.priority !== undefined ? task.priority : 5, queuedAt: Date.now() });
       scheduler.queue.sort((a, b) => (a.priority - b.priority) || (a.queuedAt - b.queuedAt));
       return null;
     }
-    console.log(`[dsh-cron] Task "${task.title}" (${taskId}) skipped: concurrency limit (${scheduler.maxConcurrent})`);
+    logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) skipped: concurrency limit (${scheduler.maxConcurrent})`);
     scheduler.recordSkipped(taskId, `Skipped: concurrency limit reached (${scheduler.maxConcurrent} parallel runs)`);
     return null;
   }
@@ -157,16 +158,16 @@ export function beginRun(scheduler, task, taskId) {
   const active = scheduler.running.get(taskId);
   if (active) {
     if (overlapPolicy === 'skip') {
-      console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, skipping run (overlapPolicy: skip)`);
+      logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, skipping run (overlapPolicy: skip)`);
       scheduler.recordSkipped(taskId, 'Skipped: the previous run is still in progress (overlapPolicy: skip)');
       return null;
     }
     if (overlapPolicy === 'replace') {
-      console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, canceling current run (overlapPolicy: replace)`);
+      logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, canceling current run (overlapPolicy: replace)`);
       active.controller.abort(new Error('Aborted by overlap policy: replace'));
     }
     if (overlapPolicy === 'queue') {
-      console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, queueing next run (overlapPolicy: queue)`);
+      logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, queueing next run (overlapPolicy: queue)`);
       active.queueCount = (active.queueCount || 0) + 1;
       return null;
     }
@@ -189,7 +190,7 @@ export async function executeTask(scheduler, taskId, options = {}) {
   const runs = (scheduler.store.history && scheduler.store.history.get(taskId)) || [];
   const guard = checkTaskBudgetLimits(task, runs);
   if (guard.exceeded) {
-    console.warn(`[dsh-cron] Burn Guard pre-flight blocked task "${task.title}" (${taskId}): ${guard.reason}`);
+    logger.warn(`[dsh-cron] Burn Guard pre-flight blocked task "${task.title}" (${taskId}): ${guard.reason}`);
     scheduler.pauseTask(taskId, guard.reason);
     scheduler.recordSkipped(taskId, `Burn Guard pre-flight pause: ${guard.reason}`);
     checkAndApplyBurnGuard(scheduler, taskId, { status: 'error', costUsd: 0, durationMs: 0 }).catch(() => {});
@@ -222,7 +223,7 @@ export async function executeTask(scheduler, taskId, options = {}) {
 
   const preflight = await executePreflight(task);
   if (!preflight.ok) {
-    console.log(`[dsh-cron] task "${task.title}" (${taskId}) skipped: ${preflight.reason}`);
+    logger.info(`[dsh-cron] task "${task.title}" (${taskId}) skipped: ${preflight.reason}`);
     scheduler.running.delete(taskId);
     scheduler.recordSkipped(taskId, `Preflight check skipped: ${preflight.reason}`);
     return null;
@@ -282,18 +283,18 @@ export async function applyModelAssists(task, runInfo, options) {
     runInfo.diagnosis = inspection.diagnosis;
     runInfo.suggestion = inspection.suggestion;
     runInfo.confidence = inspection.confidence;
-    console.log(`[dsh-cron] task "${task.title}" failure diagnosed (${inspection.confidence}): ${inspection.diagnosis}`);
+    logger.info(`[dsh-cron] task "${task.title}" failure diagnosed (${inspection.confidence}): ${inspection.diagnosis}`);
   } else if (inspection.error && task.inspectOnFailure) {
-    console.warn(`[dsh-cron] failure inspection for "${task.title}" not applied: ${inspection.error}`);
+    logger.warn(`[dsh-cron] failure inspection for "${task.title}" not applied: ${inspection.error}`);
   }
 
   const silent = await applySilentRuleToRun(task, runInfo, options);
   if (silent.skipped) {
     runInfo.silentSkip = true;
     runInfo.silentReason = silent.reason;
-    console.log(`[dsh-cron] task "${task.title}" stayed silent by rule: ${silent.reason || 'no reason given'}`);
+    logger.info(`[dsh-cron] task "${task.title}" stayed silent by rule: ${silent.reason || 'no reason given'}`);
   } else if (silent.verdictError) {
-    console.warn(`[dsh-cron] silent rule for "${task.title}" not applied: ${silent.verdictError}`);
+    logger.warn(`[dsh-cron] silent rule for "${task.title}" not applied: ${silent.verdictError}`);
   }
   return silent;
 }
@@ -308,19 +309,19 @@ export async function deliverNotifications(task, runInfo, { store, resolveSecret
       try {
         settings = { ...settings, ...(await resolveSecrets(settings)) };
       } catch (secErr) {
-        console.warn('[dsh-cron] credential resolution failed:', secErr.message);
+        logger.warn('[dsh-cron] credential resolution failed:', secErr.message);
       }
     }
     if (typeof deliver !== 'function') return;
     const result = await deliver(task, runInfo, settings);
     if (result && Array.isArray(result.delivered) && result.delivered.length) {
-      console.log(`[dsh-cron] delivered "${task.title}" to: ${result.delivered.map((d) => d.channel).join(', ')}`);
+      logger.info(`[dsh-cron] delivered "${task.title}" to: ${result.delivered.map((d) => d.channel).join(', ')}`);
     }
     if (result && Array.isArray(result.failures) && result.failures.length) {
-      console.warn(`[dsh-cron] delivery failures for "${task.title}": ${result.failures.map((f) => `${f.channel}: ${f.error}`).join('; ')}`);
+      logger.warn(`[dsh-cron] delivery failures for "${task.title}": ${result.failures.map((f) => `${f.channel}: ${f.error}`).join('; ')}`);
     }
   } catch (notifyErr) {
-    console.error('[dsh-cron] notification error:', notifyErr.message);
+    logger.error('[dsh-cron] notification error:', notifyErr.message);
   }
 }
 
@@ -343,7 +344,7 @@ export function finishRun(scheduler, task, taskId, status, queuedCount) {
       }
     }
   } catch (err) {
-    console.error('[dsh-cron] failed to persist the next run of task', taskId + ':', err.message);
+    logger.error('[dsh-cron] failed to persist the next run of task', taskId + ':', err.message);
   }
 
   try {
@@ -359,7 +360,7 @@ export function finishRun(scheduler, task, taskId, status, queuedCount) {
         scheduler.retryTimers.delete(taskId);
         scheduler.runTask(taskId, { isRetry: true });
       }, backoffMs));
-      console.log(`[dsh-cron] retry ${attempt}/${maxRetries} for task "${task.title}" in ${backoffMs}ms`);
+      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);
@@ -368,7 +369,7 @@ export function finishRun(scheduler, task, taskId, status, queuedCount) {
       scheduler.store.set(task);
     }
   } catch (err) {
-    console.error('[dsh-cron] retry bookkeeping failed for task', taskId + ':', err.message);
+    logger.error('[dsh-cron] retry bookkeeping failed for task', taskId + ':', err.message);
   }
 
   if (queuedCount > 0) {
@@ -398,7 +399,7 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
   };
 
   if (isFailure && task.selfHealingCommand) {
-    console.log(`[dsh-cron] running self-healing command for task "${task.title}": ${task.selfHealingCommand}`);
+    logger.info(`[dsh-cron] running self-healing command for task "${task.title}": ${task.selfHealingCommand}`);
     try {
       await new Promise((resolve) => {
         exec(task.selfHealingCommand, { timeout: 30000 }, (shErr, stdout, stderr) => {
@@ -435,7 +436,7 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
   try {
     scheduler.store.recordRun(taskId, runInfo);
   } catch (recordErr) {
-    console.error(`[dsh-cron] failed to record the run of task ${taskId}:`, recordErr.message);
+    logger.error(`[dsh-cron] failed to record the run of task ${taskId}:`, recordErr.message);
   }
 
   const finishedRun = scheduler.running.get(taskId);
@@ -480,7 +481,7 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
         }
       }
     } catch (actErr) {
-      console.warn(`[dsh-cron] structured action error for ${taskId}:`, actErr.message);
+      logger.warn(`[dsh-cron] structured action error for ${taskId}:`, actErr.message);
     }
   }
 
@@ -492,7 +493,7 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
       const targetId = nextTaskId.trim();
       const nextTask = scheduler.store.get(targetId);
       if (nextTask) {
-        console.log(`[dsh-cron] triggering chained task "${nextTask.title}" (${targetId}) from "${task.title}" (depth ${currentDepth + 1})`);
+        logger.info(`[dsh-cron] triggering chained task "${nextTask.title}" (${targetId}) from "${task.title}" (depth ${currentDepth + 1})`);
         scheduler.runNow(targetId, {
           chainDepth: currentDepth + 1,
           prevOutput: outcome.output || outcome.error || '',
@@ -501,13 +502,13 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
           prevDurationMs: Date.now() - start,
           prevCostUsd: outcome.costUsd || 0,
         }).catch((err) => {
-          console.warn(`[dsh-cron] chained task ${targetId} failed to trigger:`, err.message);
+          logger.warn(`[dsh-cron] chained task ${targetId} failed to trigger:`, err.message);
         });
       } else {
-        console.warn(`[dsh-cron] chained task target not found: ${targetId}`);
+        logger.warn(`[dsh-cron] chained task target not found: ${targetId}`);
       }
     } else {
-      console.warn(`[dsh-cron] chained task depth limit (5) reached for task ${task.id} -> ${nextTaskId}. Loop prevented.`);
+      logger.warn(`[dsh-cron] chained task depth limit (5) reached for task ${task.id} -> ${nextTaskId}. Loop prevented.`);
     }
   }
 }

package/lib/scheduler-lifecycle.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 
 /**
@@ -41,7 +42,7 @@ export async function checkHeartbeats(scheduler) {
       task.updatedAt = now;
       scheduler.store.save();
 
-      console.warn(`[dsh-cron] Heartbeat missed for "${task.title}" (${task.id})!`);
+      logger.warn(`[dsh-cron] Heartbeat missed for "${task.title}" (${task.id})!`);
       const runInfo = {
         at: now,
         status: 'missed',
@@ -62,7 +63,7 @@ export async function checkHeartbeats(scheduler) {
           chainDepth: 1,
           prevOutput: runInfo.output,
           prevTaskId: task.id,
-        }).catch((err) => console.warn('[dsh-cron] heartbeat onFailure trigger error:', err.message));
+        }).catch((err) => logger.warn('[dsh-cron] heartbeat onFailure trigger error:', err.message));
       }
     }
   }

package/lib/scheduler.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 import { Cron } from 'croner';
 import {
@@ -297,7 +298,7 @@ export class TaskScheduler {
       if (missed) {
         const missedAt = task.nextRunAt;
         const policy = task.misfirePolicy || 'skip';
-        console.warn(`[dsh-cron] Task "${task.title}" (${task.id}) missed scheduled run at ${new Date(missedAt).toISOString()} (misfire: ${policy})`);
+        logger.warn(`[dsh-cron] Task "${task.title}" (${task.id}) missed scheduled run at ${new Date(missedAt).toISOString()} (misfire: ${policy})`);
         this.countRun('missed');
         this.store.recordRun(task.id, {
           at: missedAt,
@@ -369,7 +370,7 @@ export class TaskScheduler {
     const timer = setTimeout(() => {
       this.timers.delete(task.id);
       this.runTask(task.id).catch((err) => {
-        console.error(`[dsh-cron] one-shot run of task ${task.id} failed:`, (err && err.message) || err);
+        logger.error(`[dsh-cron] one-shot run of task ${task.id} failed:`, (err && err.message) || err);
       });
     }, delay);
     this.timers.set(task.id, timer);
@@ -380,7 +381,7 @@ export class TaskScheduler {
     const job = new Cron(parsed.cronPattern, {
       protect: true,
       sloppyRanges: true,
-      catch: (err) => console.error(`[dsh-cron] scheduled run of "${task.title}" (${task.id}) failed:`, (err && err.message) || err),
+      catch: (err) => logger.error(`[dsh-cron] scheduled run of "${task.title}" (${task.id}) failed:`, (err && err.message) || err),
       ...(timezone ? { timezone } : {}),
     }, async () => {
       await this.runTask(task.id);
@@ -407,7 +408,7 @@ export class TaskScheduler {
       }
       this.scheduleCron(task, parsed);
     } catch (err) {
-      console.error(`[dsh-cron] failed to schedule task ${task.id}:`, err.message);
+      logger.error(`[dsh-cron] failed to schedule task ${task.id}:`, err.message);
     }
   }
 

package/lib/settings.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import z from '@deepseek-ai/schemastery';
 import { credentialRefStatus } from './secrets.js';
 import { TaskStore } from './store.js';
@@ -147,14 +148,14 @@ export function sanitizeSettingsPayload(body) {
     if (key in payload && typeof payload[key] === 'string' && payload[key].trim()) {
       const refCheck = credentialRefStatus(payload[key]);
       if (!refCheck.ok) {
-        console.warn(`[dsh-cron] invalid credential reference in "${key}": ${refCheck.error}`);
+        logger.warn(`[dsh-cron] invalid credential reference in "${key}": ${refCheck.error}`);
         delete payload[key];
       }
     }
   }
   for (const key of TaskStore.FORBIDDEN_SETTING_KEYS) {
     if (key in payload) {
-      console.warn(`[dsh-cron] refusing raw secret "${key}" from the client — use a credential reference`);
+      logger.warn(`[dsh-cron] refusing raw secret "${key}" from the client — use a credential reference`);
       delete payload[key];
     }
   }

package/lib/store.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -74,21 +75,21 @@ export class TaskStore {
           bestEffort('backup-initial', () => fs.copyFileSync(this.filePath, bakPath));
         }
       } catch (err) {
-        console.error('[dsh-cron] store read error (corrupted file):', err.message);
+        logger.error('[dsh-cron] store read error (corrupted file):', err.message);
         try {
           const corruptedPath = `${this.filePath}.corrupted.${Date.now()}`;
           fs.copyFileSync(this.filePath, corruptedPath);
-          console.warn(`[dsh-cron] corrupted store backed up to ${corruptedPath}`);
+          logger.warn(`[dsh-cron] corrupted store backed up to ${corruptedPath}`);
         } catch (snapErr) {
-          console.error('[dsh-cron] failed to snapshot corrupted store:', snapErr.message);
+          logger.error('[dsh-cron] failed to snapshot corrupted store:', snapErr.message);
         }
         if (fs.existsSync(bakPath)) {
           try {
             const rawBak = fs.readFileSync(bakPath, 'utf-8');
             loadData(rawBak);
-            console.warn(`[dsh-cron] successfully recovered tasks store from ${bakPath}`);
+            logger.warn(`[dsh-cron] successfully recovered tasks store from ${bakPath}`);
           } catch (bakErr) {
-            console.error('[dsh-cron] failed to recover tasks store from .bak:', bakErr.message);
+            logger.error('[dsh-cron] failed to recover tasks store from .bak:', bakErr.message);
           }
         }
       }
@@ -97,9 +98,9 @@ export class TaskStore {
         const rawBak = fs.readFileSync(bakPath, 'utf-8');
         loadData(rawBak);
         bestEffort('restore-from-bak', () => fs.copyFileSync(bakPath, this.filePath));
-        console.warn(`[dsh-cron] restored missing tasks store from ${bakPath}`);
+        logger.warn(`[dsh-cron] restored missing tasks store from ${bakPath}`);
       } catch (bakErr) {
-        console.error('[dsh-cron] failed to restore tasks store from .bak:', bakErr.message);
+        logger.error('[dsh-cron] failed to restore tasks store from .bak:', bakErr.message);
       }
     }
   }
@@ -158,7 +159,7 @@ export class TaskStore {
         bestEffort('backup-on-save', () => fs.copyFileSync(this.filePath, `${this.filePath}.bak`));
       }
     } catch (err) {
-      console.error('[dsh-cron] store save error:', err.message);
+      logger.error('[dsh-cron] store save error:', err.message);
     }
   }
 
@@ -222,7 +223,7 @@ export class TaskStore {
 
     for (const key of TaskStore.FORBIDDEN_SETTING_KEYS) {
       if (key in patch) {
-        console.warn(`[dsh-cron] refusing to store raw secret "${key}" in settings — use a credential reference instead`);
+        logger.warn(`[dsh-cron] refusing to store raw secret "${key}" in settings — use a credential reference instead`);
         delete patch[key];
       }
     }
@@ -441,7 +442,7 @@ export class TaskStore {
       fs.writeFileSync(tmp, JSON.stringify(archive), 'utf-8');
       fs.renameSync(tmp, archivePath);
     } catch (archiveErr) {
-      console.error('[dsh-cron] history archive error:', archiveErr.message);
+      logger.error('[dsh-cron] history archive error:', archiveErr.message);
     }
   }
 

package/lib/task-patch.js

@@ -1,5 +1,5 @@
 /**
- * Partial task updates, shared by the HTTP PATCH route and the cron_update_task
+ * Partial task updates, shared by the HTTP PATCH route and the cron tool (action: 'update')
  * tool (#49).
  *
  * One implementation keeps the whitelist, the type validation, the schedule

package/lib/telegram.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
@@ -63,7 +64,7 @@ export function getDshDefaultTelegramCredentials() {
       try {
         raw = fs.readFileSync(p, 'utf-8');
       } catch (readErr) {
-        console.warn('[dsh-cron] default Telegram credentials: cannot read DSH settings.yaml:', readErr.message);
+        logger.warn('[dsh-cron] default Telegram credentials: cannot read DSH settings.yaml:', readErr.message);
         return { botToken: undefined, chatId: undefined };
       }
       const botToken = extractSettingFromYaml(raw, 'dsh-messenger-gateway', 'botToken');
@@ -71,7 +72,7 @@ export function getDshDefaultTelegramCredentials() {
       return { botToken, chatId };
     }
   } catch (err) {
-    console.warn('[dsh-cron] default Telegram credentials lookup failed:', err.message);
+    logger.warn('[dsh-cron] default Telegram credentials lookup failed:', err.message);
   }
   return { botToken: undefined, chatId: undefined };
 }
@@ -153,7 +154,7 @@ export async function answerTelegramCallbackQuery({ botToken, callbackQueryId, t
       body: JSON.stringify(body),
     });
   } catch (err) {
-    console.warn('[dsh-cron] answerCallbackQuery failed:', err.message);
+    logger.warn('[dsh-cron] answerCallbackQuery failed:', err.message);
   }
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.2.28",
-  "description": "Scheduled cron tasks, background automation and agent execution for DeepSeek Harness.",
+  "version": "0.2.30",
+  "description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
   "type": "module",
   "main": "lib/index.js",
   "exports": {