@goodandready/dsh-cron 0.1.15 → 0.1.16

package/README.md

@@ -116,6 +116,15 @@ Direct integration with the Telegram Bot API delivers execution reports and erro
 * **Markdown Formatting**: Messages are formatted with status badges (✅ / ❌), execution duration in milliseconds, schedule descriptions, and monospace code blocks.
 * **Test Dispatch Button**: Verify Telegram connectivity on the spot before scheduling critical production jobs.
 
+### 7. Overlap Policies & Execution Timeout Control (Issues #11, #17)
+Prevent rogue processes from consuming server resources or stacking concurrent duplicate executions:
+
+* **Execution Timeout (`timeoutSeconds`)**: Automatically cancels agent sessions or kills shell subprocesses when the configured run time limit is reached (default: 1800s / 30m). Prevents hung tasks and records a descriptive timeout failure in run logs.
+* **Overlap Policy (`overlapPolicy`)**: Controls scheduler behavior when a scheduled tick fires while the previous execution is still running:
+  * **`skip`** (default): Drops the overlapping run and records a `skipped` status entry in the run history without spamming.
+  * **`queue`**: Queues the next execution and starts it automatically as soon as the active job completes.
+  * **`replace`**: Aborts the stuck/active run immediately via `AbortController` and launches the fresh execution.
+
 ### 5. Schedule Expression Syntax
 Powered by `croner`, supporting both standard 5-part/6-part cron expressions and user-friendly interval aliases:
 

package/lib/client.js

@@ -136,6 +136,7 @@ const React = window.React || require('react');
       .dsh-cron-history-status { font-weight: 600; font-size: 11.5px; text-transform: uppercase; padding: 2px 6px; border-radius: 4px; }
       .dsh-cron-history-status[data-status="success"] { background: rgba(16, 185, 129, 0.15); color: #10b981; }
       .dsh-cron-history-status[data-status="error"] { background: rgba(239, 68, 68, 0.15); color: #ef4444; }
+      .dsh-cron-history-status[data-status="skipped"] { background: rgba(234, 179, 8, 0.15); color: #eab308; }
       .dsh-cron-history-time { color: #777; font-size: 12px; }
       .dsh-cron-history-output { background: #0c0c0c; border: 1px solid #222; border-radius: 6px; padding: 8px 10px; font-family: monospace; font-size: 12px; color: #bbb; max-height: 140px; overflow-y: auto; white-space: pre-wrap; word-break: break-all; margin-top: 6px; }
       .dsh-cron-history-empty { text-align: center; padding: 36px 0; color: #666; font-size: 13.5px; }
@@ -248,6 +249,8 @@ const React = window.React || require('react');
       const [historyLoading, setHistoryLoading] = React.useState(false);
       const [formNotifyTelegram, setFormNotifyTelegram] = React.useState(false);
       const [formOnlyOnFailure, setFormOnlyOnFailure] = React.useState(false);
+      const [formTimeoutSeconds, setFormTimeoutSeconds] = React.useState(1800);
+      const [formOverlapPolicy, setFormOverlapPolicy] = React.useState('skip');
 
       // Settings modal state
       const [settingsModalOpen, setSettingsModalOpen] = React.useState(false);
@@ -401,6 +404,8 @@ const React = window.React || require('react');
         setFormDelivery('isolated');
         setFormNotifyTelegram(false);
         setFormOnlyOnFailure(false);
+        setFormTimeoutSeconds(1800);
+        setFormOverlapPolicy('skip');
         if (preset) {
           setFormTitle(preset.title || '');
           setFormSchedule(preset.schedule || '');
@@ -448,6 +453,8 @@ const React = window.React || require('react');
         setFormDelivery(task.delivery || 'isolated');
         setFormNotifyTelegram(Boolean(task.notifyTelegram));
         setFormOnlyOnFailure(Boolean(task.onlyOnFailure));
+        setFormTimeoutSeconds(task.timeoutSeconds !== undefined ? task.timeoutSeconds : 1800);
+        setFormOverlapPolicy(task.overlapPolicy || 'skip');
         if (task.provider) loadModels(task.provider);
         else if (defaultModelInfo?.provider) loadModels(defaultModelInfo.provider);
         loadTaskHistory(task.id);
@@ -718,7 +725,7 @@ const React = window.React || require('react');
                       React.createElement('span', {
                         className: 'dsh-cron-history-status',
                         'data-status': run.status
-                      }, run.status === 'success' ? 'Успешно' : 'Ошибка'),
+                      }, run.status === 'success' ? 'Успешно' : run.status === 'skipped' ? 'Пропущен' : 'Ошибка'),
                       React.createElement('span', { className: 'dsh-cron-history-time' }, run.at ? new Date(run.at).toLocaleString() : '')
                     ),
                     React.createElement('span', { style: { color: '#888', fontSize: '11.5px' } }, (run.durationMs || 0) + ' ms')
@@ -772,6 +779,29 @@ const React = window.React || require('react');
                   })
                 )
               ),
+              React.createElement('div', { className: 'dsh-cron-form-row', style: { display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '12px' } },
+                React.createElement('div', { className: 'dsh-cron-form-group' },
+                  React.createElement('label', null, 'Таймаут выполнения (секунды)'),
+                  React.createElement('input', {
+                    type: 'number',
+                    min: 1,
+                    value: formTimeoutSeconds,
+                    placeholder: '1800',
+                    onChange: (e) => setFormTimeoutSeconds(e.target.value)
+                  })
+                ),
+                React.createElement('div', { className: 'dsh-cron-form-group' },
+                  React.createElement('label', null, 'Политика наложения (Overlap)'),
+                  React.createElement('select', {
+                    value: formOverlapPolicy,
+                    onChange: (e) => setFormOverlapPolicy(e.target.value)
+                  },
+                    React.createElement('option', { value: 'skip' }, 'Пропустить новый запуск (skip)'),
+                    React.createElement('option', { value: 'queue' }, 'Встать в очередь (queue)'),
+                    React.createElement('option', { value: 'replace' }, 'Отменить текущий и перезапустить (replace)')
+                  )
+                )
+              ),
               formType !== 'script' && React.createElement('div', { className: 'dsh-cron-form-row', style: { display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '12px' } },
                 React.createElement('div', { className: 'dsh-cron-form-group' },
                   React.createElement('label', null, 'Провайдер LLM'),

package/lib/index.js

@@ -33,7 +33,7 @@ function sendJson(res, statusCode, data) {
 export function apply(ctx, config) {
   const store = new TaskStore();
   const runner = new SessionRunner(ctx);
-  const scheduler = new TaskScheduler(store, (task) => runner.execute(task));
+  const scheduler = new TaskScheduler(store, (task, opts) => runner.execute(task, opts));
 
   scheduler.start();
 
@@ -109,6 +109,8 @@ export function apply(ctx, config) {
             model: body.model || undefined,
             notifyTelegram: body.notifyTelegram !== undefined ? Boolean(body.notifyTelegram) : false,
             onlyOnFailure: body.onlyOnFailure !== undefined ? Boolean(body.onlyOnFailure) : false,
+            timeoutSeconds: body.timeoutSeconds !== undefined ? Number(body.timeoutSeconds) : 1800,
+            overlapPolicy: body.overlapPolicy || 'skip',
           });
           scheduler.scheduleTask(task);
           sendJson(res, 200, { ok: true, task });
@@ -270,7 +272,9 @@ export function apply(ctx, config) {
         provider: { type: 'string', description: 'ID провайдера LLM для выполнения задачи' },
         model: { type: 'string', description: 'ID модели LLM для выполнения задачи' },
         notifyTelegram: { type: 'boolean', description: 'Отправлять отчет в Telegram' },
-        onlyOnFailure: { type: 'boolean', description: 'Отправлять в Telegram только при ошибках' }
+        onlyOnFailure: { type: 'boolean', description: 'Отправлять в Telegram только при ошибках' },
+        timeoutSeconds: { type: 'integer', description: 'Таймаут выполнения задачи в секундах (по умолчанию 1800 = 30 мин)' },
+        overlapPolicy: { type: 'string', description: 'Политика наложения: "skip" (по умолчанию), "queue", "replace"' }
       },
       output: {
         schema: {
@@ -285,7 +289,7 @@ export function apply(ctx, config) {
           return [{ type: 'text', text: value.message }];
         }
       },
-      execute: async ({ title, schedule, prompt, delivery, provider, model, type, notifyTelegram, onlyOnFailure }) => {
+      execute: async ({ title, schedule, prompt, delivery, provider, model, type, notifyTelegram, onlyOnFailure, timeoutSeconds, overlapPolicy }) => {
         try {
           const parsed = parseScheduleExpression(schedule);
           const task = store.set({
@@ -299,6 +303,8 @@ export function apply(ctx, config) {
             model: model || undefined,
             notifyTelegram: Boolean(notifyTelegram),
             onlyOnFailure: Boolean(onlyOnFailure),
+            timeoutSeconds: timeoutSeconds !== undefined ? Number(timeoutSeconds) : 1800,
+            overlapPolicy: overlapPolicy || 'skip',
             status: 'active'
           });
           scheduler.scheduleTask(task);

package/lib/runner.js

@@ -6,25 +6,62 @@ export class SessionRunner {
     this.ctx = ctx;
   }
 
-    async execute(task) {
+  async execute(task, options = {}) {
+    const timeoutSeconds = Number(task.timeoutSeconds) > 0 ? Number(task.timeoutSeconds) : 1800;
+    const timeoutMs = timeoutSeconds * 1000;
+    const externalSignal = options.signal;
+
+    // Internal abort controller combining external signal + timeout
+    const controller = new AbortController();
+    let timeoutId = null;
+
+    if (externalSignal) {
+      if (externalSignal.aborted) {
+        throw new Error(externalSignal.reason?.message || 'Task aborted before execution');
+      }
+      externalSignal.addEventListener('abort', () => {
+        controller.abort(externalSignal.reason || new Error('Task aborted by overlap policy'));
+      }, { once: true });
+    }
+
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        const timeoutErr = new Error(`Task execution timed out after ${timeoutSeconds} seconds`);
+        controller.abort(timeoutErr);
+        reject(timeoutErr);
+      }, timeoutMs);
+    });
+
+    const executionPromise = this._run(task, controller.signal);
+
+    try {
+      return await Promise.race([executionPromise, timeoutPromise]);
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
+  }
+
+  async _run(task, signal) {
     console.log(`[dsh-cron] executing task "${task.title}" (${task.id})`);
     
     // 1. Direct shell / script task fallback (NO-LLM)
     if (task.type === 'script' || task.mode === 'no-llm') {
       const { exec } = await import('node:child_process');
-      const { promisify } = await import('node:util');
-      const execAsync = promisify(exec);
-      try {
-        const { stdout, stderr } = await execAsync(task.prompt, {
-          timeout: 60000,
-          cwd: process.cwd()
+      return new Promise((resolve, reject) => {
+        const child = exec(task.prompt, {
+          cwd: process.cwd(),
+          signal,
+        }, (err, stdout, stderr) => {
+          if (err) {
+            if (signal && signal.aborted) {
+              return reject(signal.reason || new Error('Command aborted'));
+            }
+            return reject(err);
+          }
+          const out = (stdout || stderr || '').trim();
+          resolve(out || 'Script completed with code 0');
         });
-        const out = (stdout || stderr || '').trim();
-        return out || 'Script completed with code 0';
-      } catch (err) {
-        console.error(`[dsh-cron] script task failed:`, err.message);
-        throw err;
-      }
+      });
     }
 
     // 2. If ctx.agents is available, run through agent session (LLM)
@@ -59,6 +96,10 @@ export class SessionRunner {
           agentOptions: provider && model ? { provider, model } : undefined,
         });
 
+        if (signal && signal.aborted) {
+          throw (signal.reason || new Error('Aborted'));
+        }
+
         await handle.agent.whenIdle();
         handle.agent.followup(createUserMessage({
           content: [{ type: 'text', text: task.prompt }],
@@ -92,4 +133,4 @@ export class SessionRunner {
 
     return `[dsh-cron] Prompt triggered: "${task.prompt.slice(0, 100)}..."`;
   }
-}
+}

package/lib/scheduler.js

@@ -83,6 +83,7 @@ export class TaskScheduler {
     this.store = store;
     this.executeFn = executeFn;
     this.jobs = new Map();
+    this.running = new Map(); // taskId -> { controller, startedAt, queueCount }
   }
 
   start() {
@@ -101,6 +102,13 @@ export class TaskScheduler {
       } catch {}
     }
     this.jobs.clear();
+
+    for (const [, run] of this.running.entries()) {
+      try {
+        run.controller.abort(new Error('Планировщик остановлен'));
+      } catch {}
+    }
+    this.running.clear();
   }
 
   scheduleTask(task) {
@@ -132,6 +140,41 @@ export class TaskScheduler {
     const task = this.store.get(taskId);
     if (!task) return;
 
+    const overlapPolicy = task.overlapPolicy || 'skip';
+
+    // Check overlap with currently running task
+    const active = this.running.get(taskId);
+    if (active) {
+      if (overlapPolicy === 'skip') {
+        console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, skipping run (overlapPolicy: skip)`);
+        this.store.recordRun(taskId, {
+          at: Date.now(),
+          status: 'skipped',
+          durationMs: 0,
+          output: 'Запуск пропущен: предыдущий процесс ещё не завершился (overlapPolicy: skip)',
+          error: null,
+        });
+        return;
+      }
+      if (overlapPolicy === 'replace') {
+        console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, canceling current run (overlapPolicy: replace)`);
+        active.controller.abort(new Error('Прервано из-за политики overlap: replace'));
+      }
+      if (overlapPolicy === 'queue') {
+        console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, queueing next run (overlapPolicy: queue)`);
+        active.queueCount = (active.queueCount || 0) + 1;
+        return;
+      }
+    }
+
+    const controller = new AbortController();
+    const currentRun = {
+      controller,
+      startedAt: Date.now(),
+      queueCount: 0,
+    };
+    this.running.set(taskId, currentRun);
+
     const start = Date.now();
     let status = 'success';
     let output = '';
@@ -139,7 +182,7 @@ export class TaskScheduler {
 
     try {
       if (typeof this.executeFn === 'function') {
-        output = await this.executeFn(task);
+        output = await this.executeFn(task, { signal: controller.signal });
       }
     } catch (err) {
       status = 'error';
@@ -155,6 +198,14 @@ export class TaskScheduler {
       };
       this.store.recordRun(taskId, runInfo);
 
+      // Clean up running map
+      const finishedRun = this.running.get(taskId);
+      if (finishedRun === currentRun) {
+        this.running.delete(taskId);
+      }
+
+      const queuedCount = finishedRun?.queueCount || 0;
+
       // Telegram notification delivery
       try {
         const settings = typeof this.store.getSettings === 'function' ? this.store.getSettings() : {};
@@ -178,6 +229,12 @@ export class TaskScheduler {
         task.nextRunAt = next ? next.getTime() : null;
         this.store.set(task);
       }
+
+      if (queuedCount > 0) {
+        setImmediate(() => {
+          this.runTask(taskId);
+        });
+      }
     }
   }
 
@@ -190,6 +247,11 @@ export class TaskScheduler {
       this.jobs.get(taskId).stop();
       this.jobs.delete(taskId);
     }
+    const running = this.running.get(taskId);
+    if (running) {
+      running.controller.abort(new Error('Задача приостановлена'));
+      this.running.delete(taskId);
+    }
     this.store.set(task);
     return task;
   }
@@ -208,6 +270,11 @@ export class TaskScheduler {
       this.jobs.get(taskId).stop();
       this.jobs.delete(taskId);
     }
+    const running = this.running.get(taskId);
+    if (running) {
+      running.controller.abort(new Error('Задача удалена'));
+      this.running.delete(taskId);
+    }
     return this.store.delete(taskId);
   }
 

package/lib/store.js

@@ -127,6 +127,8 @@ export class TaskStore {
       model: task.model !== undefined ? task.model : prev.model,
       notifyTelegram: task.notifyTelegram !== undefined ? Boolean(task.notifyTelegram) : (prev.notifyTelegram || false),
       onlyOnFailure: task.onlyOnFailure !== undefined ? Boolean(task.onlyOnFailure) : (prev.onlyOnFailure || false),
+      timeoutSeconds: task.timeoutSeconds !== undefined ? Number(task.timeoutSeconds) : (prev.timeoutSeconds || 1800),
+      overlapPolicy: task.overlapPolicy !== undefined ? String(task.overlapPolicy) : (prev.overlapPolicy || 'skip'),
       createdAt: prev.createdAt || task.createdAt || now,
       updatedAt: now,
       lastRunAt: task.lastRunAt !== undefined ? task.lastRunAt : (prev.lastRunAt || null),

package/package.json

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