@goodandready/dsh-cron 0.2.10 → 0.2.12

package/lib/index.js

@@ -393,6 +393,24 @@ export function apply(ctx, config) {
     handler: createCronApiHandler(store, scheduler, null)
   }), 'dsh-cron: /action/:id/:action');
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/telegram',
+    handler: createCronApiHandler(store, scheduler, null)
+  }), 'dsh-cron: /telegram[...]');
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/heartbeat-ping',
+    handler: createCronApiHandler(store, scheduler, null)
+  }), 'dsh-cron: /heartbeat-ping[...]');
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/schedule',
+    handler: createCronApiHandler(store, scheduler, null)
+  }), 'dsh-cron: /schedule[...]');
+
   // GET /dsh-cron/metrics (#53) — Prometheus text exposition
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',

package/lib/runner.js

@@ -457,10 +457,38 @@ ${prompt}`;
   async _executeAgentTurn(task, prep) {
     let handle = null;
     try {
+      // Resolve agent preset (#GH-1): scheduled llm sessions must join an agent preset
+      // (default or task-configured), otherwise tools resolve against the empty global layer.
+      const presets = this.ctx.agentPresets || (this.ctx.get && this.ctx.get('agentPresets'));
+      let preset = null;
+      if (presets && typeof presets.resolve === 'function') {
+        try {
+          preset = await presets.resolve(task.agentPreset || undefined);
+          if (preset && typeof presets.standingKeyFor === 'function') {
+            await presets.standingKeyFor(preset.id);
+          }
+        } catch (presetErr) {
+          console.warn('[dsh-cron] agent preset unavailable, running without one:', presetErr && presetErr.message);
+          preset = null;
+        }
+      }
+
       handle = await this.ctx.agents.create({
         sessionId: prep.mintSessionId(),
-        meta: { cwd: prep.cwd, ephemeral: true, internal: true },
+        meta: {
+          cwd: prep.cwd,
+          ephemeral: true,
+          internal: true,
+          ...(preset ? { agentPreset: preset.id } : {})
+        },
         agentOptions: prep.provider && prep.model ? { provider: prep.provider, model: prep.model } : undefined,
+        ...(preset ? {
+          setup: async (agentCtx) => {
+            if (typeof presets.mount === 'function') {
+              await presets.mount(agentCtx, preset.id);
+            }
+          }
+        } : {}),
       });
       this._applyPermissionPreset(task, handle);
       await prep.raceAbort(handle.agent.whenIdle());

package/lib/scheduler.js

@@ -1,4 +1,6 @@
 import { Cron } from 'croner';
+import { exec } from 'node:child_process';
+import fs from 'node:fs';
 import { parseLlmActionDirectives, executeLlmActionDirectives } from './llm-actions.js';
 import { applySilentRule } from './silent-rule.js';
 import { inspectFailure } from './failure-inspector.js';
@@ -166,6 +168,98 @@ export function parseScheduleExpression(input) {
     || parseCronExpression(str);
 }
 
+/**
+ * Preview future execution timestamps for a cron or interval schedule.
+ */
+export function previewSchedule(scheduleStr, options = {}) {
+  const str = String(scheduleStr || '').trim();
+  if (!str) throw new Error('Schedule expression must not be empty');
+  const parsed = parseScheduleExpression(str);
+  const count = Math.min(Math.max(Number(options.count) || 5, 1), 10);
+  const timezone = options.timezone || undefined;
+
+  if (parsed.isOneShot) {
+    return {
+      isOneShot: true,
+      humanText: parsed.humanText,
+      runs: [new Date(parsed.nextRun).toISOString()],
+    };
+  }
+
+  const job = new Cron(parsed.cronPattern, {
+    timezone,
+    sloppyRanges: true,
+  });
+  const runs = [];
+  let current = new Date();
+  for (let i = 0; i < count; i++) {
+    const next = job.nextRun(current);
+    if (!next) break;
+    runs.push(next.toISOString());
+    current = new Date(next.getTime() + 1000);
+  }
+  return {
+    isOneShot: false,
+    cronPattern: parsed.cronPattern,
+    humanText: describeCron(parsed.cronPattern),
+    runs,
+  };
+}
+
+/**
+ * Execute pre-flight check gate before running task body.
+ */
+export async function executePreflight(task) {
+  const type = String(task.preflightType || 'none').toLowerCase();
+  const target = String(task.preflightTarget || '').trim();
+  if (!type || type === 'none' || !target) {
+    return { ok: true };
+  }
+
+  if (type === 'http') {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5000);
+      const res = await fetch(target, { signal: controller.signal });
+      clearTimeout(timeout);
+      if (res.ok) return { ok: true };
+      return { ok: false, reason: `HTTP check returned status ${res.status}` };
+    } catch (err) {
+      return { ok: false, reason: `HTTP check failed: ${err.message}` };
+    }
+  }
+
+  if (type === 'command') {
+    return new Promise((resolve) => {
+      exec(target, { timeout: 5000 }, (err, stdout, stderr) => {
+        if (err) {
+          resolve({ ok: false, reason: `Preflight command failed (code ${err.code || 1}): ${(stderr || stdout || err.message).trim().slice(0, 150)}` });
+        } else {
+          resolve({ ok: true });
+        }
+      });
+    });
+  }
+
+  if (type === 'disk') {
+    const requiredMb = Number(target) || 100;
+    try {
+      if (typeof fs.statfsSync === 'function') {
+        const stats = fs.statfsSync(process.cwd());
+        const freeMb = Math.round((stats.bavail * stats.bsize) / (1024 * 1024));
+        if (freeMb < requiredMb) {
+          return { ok: false, reason: `Free disk space (${freeMb} MB) is below required ${requiredMb} MB` };
+        }
+      }
+      return { ok: true };
+    } catch {
+      return { ok: true }; // Fail-open
+    }
+  }
+
+  return { ok: true };
+}
+
 export class TaskScheduler {
   constructor(store, executeFn, options = {}) {
     this.store = store;
@@ -179,6 +273,8 @@ export class TaskScheduler {
     this.retryTimers = new Map(); // taskId -> setTimeout handle (for #18 retries)
     this.running = new Map(); // taskId -> { controller, startedAt, queueCount }
     this.runCounters = {}; // status -> finished runs since start (#53, /dsh-cron/metrics)
+    this.queue = []; // [{ taskId, priority, queuedAt, options }]
+    this.heartbeatTimer = null;
   }
 
   isRunning(taskId) {
@@ -202,6 +298,67 @@ export class TaskScheduler {
     }
   }
 
+  startHeartbeatWatcher(intervalMs = 30000) {
+    this.stopHeartbeatWatcher();
+    this.heartbeatTimer = setInterval(() => this.checkHeartbeats(), intervalMs);
+    if (this.heartbeatTimer && typeof this.heartbeatTimer.unref === 'function') {
+      this.heartbeatTimer.unref();
+    }
+  }
+
+  stopHeartbeatWatcher() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  async checkHeartbeats() {
+    const now = Date.now();
+    const tasks = typeof this.store.list === 'function' ? this.store.list({ status: 'active' }) : Array.from(this.store.tasks.values());
+    for (const task of tasks) {
+      if (task.status !== 'active' || !task.heartbeatIntervalSeconds || task.heartbeatIntervalSeconds <= 0) {
+        continue;
+      }
+      const grace = task.gracePeriodSeconds !== undefined ? task.gracePeriodSeconds : 300;
+      const last = task.lastPingAt || task.createdAt || now;
+      const deadline = last + (task.heartbeatIntervalSeconds + grace) * 1000;
+
+      if (now > deadline && !task.heartbeatAlerted) {
+        task.heartbeatAlerted = true;
+        task.lastStatus = 'missed';
+        task.updatedAt = now;
+        this.store.save();
+
+        console.warn(`[dsh-cron] Heartbeat missed for "${task.title}" (${task.id})!`);
+        const runInfo = {
+          at: now,
+          status: 'missed',
+          durationMs: 0,
+          output: `Heartbeat missed: expected ping within ${task.heartbeatIntervalSeconds + grace}s, last ping was at ${new Date(last).toISOString()}`,
+          error: 'Heartbeat deadline exceeded',
+          usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+          costUsd: 0,
+        };
+
+        try {
+          this.store.recordRun(task.id, runInfo);
+        } catch {}
+
+        await this.deliverNotifications(task, runInfo);
+
+        if (task.onFailure && String(task.onFailure).trim()) {
+          const targetId = task.onFailure.trim();
+          this.runNow(targetId, {
+            chainDepth: 1,
+            prevOutput: runInfo.output,
+            prevTaskId: task.id,
+          }).catch((err) => console.warn(`[dsh-cron] heartbeat onFailure trigger error:`, err.message));
+        }
+      }
+    }
+  }
+
   start() {
     const tasks = this.store.list();
     const now = Date.now();
@@ -241,9 +398,11 @@ export class TaskScheduler {
       }
       this.scheduleTask(task);
     }
+    this.startHeartbeatWatcher();
   }
 
   stopAll() {
+    this.stopHeartbeatWatcher();
     for (const [id, job] of this.jobs.entries()) {
       try {
         job.stop();
@@ -348,6 +507,12 @@ export class TaskScheduler {
     // skipped and recorded; already-running tasks are never throttled against
     // themselves.
     if (!this.running.has(taskId) && this.maxConcurrent > 0 && this.running.size >= this.maxConcurrent) {
+      if (task.overlapPolicy === 'queue') {
+        console.log(`[dsh-cron] Task "${task.title}" (${taskId}) queued by concurrency limit (${this.maxConcurrent})`);
+        this.queue.push({ taskId, priority: task.priority !== undefined ? task.priority : 5, queuedAt: Date.now() });
+        this.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 (${this.maxConcurrent})`);
       this.recordSkipped(taskId, `Skipped: concurrency limit reached (${this.maxConcurrent} parallel runs)`);
       return null;
@@ -475,14 +640,39 @@ export class TaskScheduler {
 
   async runTask(taskId, options = {}) {
     const task = this.store.get(taskId);
-    if (!task) return;
+    if (!task) return null;
+
+    if (options.dryRun) {
+      const start = Date.now();
+      const outcome = await this.executeWithFallback(task, AbortSignal.timeout(Math.min((task.timeoutSeconds || 1800) * 1000, 30000)), options);
+      return {
+        ok: true,
+        dryRun: true,
+        status: outcome.status,
+        output: outcome.output,
+        error: outcome.error,
+        durationMs: Date.now() - start,
+        usage: outcome.usage,
+        costUsd: outcome.costUsd,
+        model: outcome.model || task.model || '',
+      };
+    }
 
     const currentRun = this.beginRun(task, taskId);
-    if (currentRun === null) return;
+    if (currentRun === null) return null;
+
+    const preflight = await executePreflight(task);
+    if (!preflight.ok) {
+      console.log(`[dsh-cron] task "${task.title}" (${taskId}) skipped: ${preflight.reason}`);
+      this.running.delete(taskId);
+      this.recordSkipped(taskId, `Preflight check skipped: ${preflight.reason}`);
+      return null;
+    }
 
     const start = Date.now();
     const outcome = await this.executeWithFallback(task, currentRun.controller.signal, options);
     await this.completeRun(task, taskId, currentRun, outcome, start, options);
+    return outcome;
   }
 
   /**
@@ -490,6 +680,8 @@ export class TaskScheduler {
    * bookkeeping. Kept separate from runTask so the run flow reads in steps.
    */
   async completeRun(task, taskId, currentRun, outcome, start, options = {}) {
+    const isSuccess = outcome.status === 'success';
+    const isFailure = outcome.status === 'error' || outcome.status === 'timeout';
     const runInfo = {
       at: start,
       status: outcome.status,
@@ -507,6 +699,40 @@ export class TaskScheduler {
 
     // #43/#44 decide before the run is recorded, so the single history entry
     // already carries the diagnosis and the silence verdict.
+    // 3. Self-healing & Auto-diagnose (#139)
+    if (isFailure && task.selfHealingCommand) {
+      console.log(`[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) => {
+            runInfo.selfHealing = {
+              command: task.selfHealingCommand,
+              success: !shErr,
+              output: (stdout + (stderr ? '\n' + stderr : '')).trim().slice(0, 500),
+            };
+            resolve();
+          });
+        });
+      } catch (shErr) {
+        runInfo.selfHealing = { command: task.selfHealingCommand, success: false, error: shErr.message };
+      }
+    }
+
+    if (isFailure && task.autoDiagnose && typeof this.executeFn === 'function') {
+      try {
+        const diagRes = await this.executeFn({
+          type: 'llm',
+          prompt: `Diagnose this task failure in 1-2 concise sentences. Error: ${outcome.error || 'unknown'}. Recent output: ${(outcome.output || '').slice(-300)}`,
+          model: task.fallbackModel || task.model,
+        }, { signal: AbortSignal.timeout(10000) });
+        if (diagRes && diagRes.output) {
+          runInfo.autoDiagnosis = diagRes.output.trim();
+        }
+      } catch {
+        // Fail-open
+      }
+    }
+
     const silent = await this.applyModelAssists(task, runInfo);
 
     try {
@@ -524,6 +750,15 @@ export class TaskScheduler {
     if (!silent.skipped) await this.deliverNotifications(task, runInfo);
     this.finishRun(task, taskId, outcome.status, queuedCount);
 
+    if (this.queue.length > 0 && this.running.size < this.maxConcurrent) {
+      const nextItem = this.queue.shift();
+      if (nextItem) {
+        setImmediate(() => {
+          this.runTask(nextItem.taskId).catch(() => {});
+        });
+      }
+    }
+
     // 1. Structured LLM Actions (#137)
     if (task.type === 'llm' && outcome.status === 'success' && outcome.output) {
       try {
@@ -546,9 +781,9 @@ export class TaskScheduler {
       }
     }
 
+    
+
     // 2. Task Chaining (#137)
-    const isSuccess = outcome.status === 'success';
-    const isFailure = outcome.status === 'error' || outcome.status === 'timeout';
     const nextTaskId = isSuccess ? task.onSuccess : (isFailure ? task.onFailure : null);
 
     if (nextTaskId && typeof nextTaskId === 'string' && nextTaskId.trim()) {

package/lib/store.js

@@ -239,6 +239,17 @@ export class TaskStore {
       onSuccess: task.onSuccess !== undefined ? String(task.onSuccess).trim() : (prev.onSuccess || ''),
       onFailure: task.onFailure !== undefined ? String(task.onFailure).trim() : (prev.onFailure || ''),
       oneShot: task.oneShot !== undefined ? Boolean(task.oneShot) : Boolean(prev.oneShot),
+      heartbeatIntervalSeconds: task.heartbeatIntervalSeconds !== undefined ? Number(task.heartbeatIntervalSeconds) : (prev.heartbeatIntervalSeconds || 0),
+      gracePeriodSeconds: task.gracePeriodSeconds !== undefined ? Number(task.gracePeriodSeconds) : (prev.gracePeriodSeconds || 300),
+      lastPingAt: task.lastPingAt !== undefined ? task.lastPingAt : (prev.lastPingAt || null),
+      heartbeatAlerted: task.heartbeatAlerted !== undefined ? Boolean(task.heartbeatAlerted) : (prev.heartbeatAlerted || false),
+      preflightType: task.preflightType !== undefined ? String(task.preflightType) : (prev.preflightType || 'none'),
+      preflightTarget: task.preflightTarget !== undefined ? String(task.preflightTarget).trim() : (prev.preflightTarget || ''),
+      concurrencyGroup: task.concurrencyGroup !== undefined ? String(task.concurrencyGroup).trim() : (prev.concurrencyGroup || 'default'),
+      priority: task.priority !== undefined ? Number(task.priority) : (prev.priority || 5),
+      selfHealingCommand: task.selfHealingCommand !== undefined ? String(task.selfHealingCommand).trim() : (prev.selfHealingCommand || ''),
+      autoDiagnose: task.autoDiagnose !== undefined ? Boolean(task.autoDiagnose) : (prev.autoDiagnose || false),
+      agentPreset: task.agentPreset !== undefined ? String(task.agentPreset).trim() : (prev.agentPreset || ''),
       totalTokens: prev.totalTokens || 0,
       totalCostUsd: prev.totalCostUsd || 0,
       createdAt: prev.createdAt || task.createdAt || now,
@@ -253,6 +264,27 @@ export class TaskStore {
     return record;
   }
 
+  recordHeartbeat(id) {
+    const task = this.tasks.get(id);
+    if (!task) return null;
+    const now = Date.now();
+    task.lastPingAt = now;
+    task.heartbeatAlerted = false;
+    task.updatedAt = now;
+    if (task.lastStatus === 'missed') {
+      task.lastStatus = 'active';
+    }
+    this.save();
+    const interval = (task.heartbeatIntervalSeconds || 0) + (task.gracePeriodSeconds || 300);
+    return {
+      ok: true,
+      id,
+      taskId: id,
+      lastPingAt: now,
+      nextDeadline: now + interval * 1000,
+    };
+  }
+
   delete(id) {
     const existed = this.tasks.delete(id);
     this.history.delete(id);
@@ -297,6 +329,8 @@ export class TaskStore {
       // #43: the failure diagnosis and the prompt change it proposes.
       diagnosis: runInfo.diagnosis ? String(runInfo.diagnosis).slice(0, 1000) : '',
       suggestion: runInfo.suggestion ? String(runInfo.suggestion).slice(0, 2000) : '',
+      selfHealing: runInfo.selfHealing || null,
+      autoDiagnosis: runInfo.autoDiagnosis ? String(runInfo.autoDiagnosis).slice(0, 1000) : '',
       confidence: runInfo.confidence || '',
     });
     // Keep up to 100 runs in active store; archive older runs to tasks-history-archive.json (#134)

package/lib/task-transfer.js

@@ -30,6 +30,7 @@ export const PATCHABLE_TASK_FIELDS = [
   'maxRetries',
   'retryBackoffMs',
   'permissionPreset',
+  'agentPreset',
   'env',
   'cwd',
   'workspaceId',
@@ -55,6 +56,14 @@ export const PATCHABLE_TASK_FIELDS = [
   'kanbanMode',
   'onSuccess',
   'onFailure',
+  'heartbeatIntervalSeconds',
+  'gracePeriodSeconds',
+  'preflightType',
+  'preflightTarget',
+  'concurrencyGroup',
+  'priority',
+  'selfHealingCommand',
+  'autoDiagnose',
   'channels',
   'template',
   'status',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Scheduled cron tasks, background automation and agent execution for DeepSeek Harness.",
   "type": "module",
   "main": "lib/index.js",