@goodandready/dsh-cron 0.2.8 → 0.2.9

package/README.md

@@ -317,6 +317,14 @@ Environment used by the check: `DSH_WEB_BASE` (default `http://127.0.0.1:3080`),
 ### 20. Internal Refactor: Schedule Parsing and Arming (#97)
 Developer-facing, no behaviour change. `parseScheduleExpression` was split into small functions that keep the same branch order — `parseAtExpression`, `parseRelativeOneShot`, `parseIntervalExpression`, `parseAliasExpression`, `parseCronExpression` — and `scheduleTask` into `clearScheduled`, `scheduleOneShot` and `scheduleCron`. The existing test suite passed unchanged and targeted tests were added for branch precedence and error messages.
 
+### 21. Performance & Process Isolation Pack (Added in v0.2.9, #134)
+- **Process-Tree Termination**: Shell and script tasks run in an isolated process group (`detached: true` on POSIX); aborts and timeouts send `SIGTERM` followed by `SIGKILL` to the entire group (`-child.pid`) to eliminate orphan and zombie processes.
+- **Concurrency Throttling**: Default safe limit `maxConcurrent = 2` prevents CPU and memory spikes during overlapping scheduled runs.
+- **Transient Error Retry**: Exponential backoff retry (up to 3 attempts) for transient network and provider errors (`429`, `502`, `503`, `504`, `ECONNRESET`).
+- **Network & UI Optimization**: `GET /dsh-cron/tasks` provides `ETag` and responds with `304 Not Modified`; client UI adapts polling frequency (`visibilitychange`: 30s in background tabs, 8s in active tabs).
+- **History Rotation & Archival**: Active store holds the latest 100 runs per task; older entries are automatically archived into `tasks-history-archive.json`.
+- **Autonomous PR Reviewer Recipe (#33)**: Preconfigured recipe in Template Hub with optional toggle `prReviewerEnabled` in settings.
+
 ---
 
 ## 📦 Installation

package/lib/api.js

@@ -5,7 +5,7 @@
  * unchanged.
  */
 
-import { randomUUID } from 'node:crypto';
+import { randomUUID, createHash } from 'node:crypto';
 import { parseScheduleExpression } from './scheduler.js';
 import { normalizeTaskType, CODE_EXECUTING_TYPES } from './runtimes.js';
 import { CHANNEL_IDS, unknownChannelIds } from './channels.js';
@@ -88,7 +88,7 @@ async function handleTaskCollection({ store, scheduler, collection, req, res, ur
     return;
   }
   if (req.method === 'GET') {
-    listTasks({ store, scheduler, collection, res, url });
+    listTasks({ store, scheduler, collection, req, res, url });
     return;
   }
   if (req.method === 'POST') {
@@ -98,7 +98,7 @@ async function handleTaskCollection({ store, scheduler, collection, req, res, ur
   sendJson(res, 405, NOT_ALLOWED);
 }
 
-function listTasks({ store, scheduler, collection, res, url }) {
+function listTasks({ store, scheduler, collection, req, res, url }) {
   const status = url.searchParams.get('status') || 'all';
   const query = url.searchParams.get('query') || '';
   const list = store.list({ status, query }).map((t) => ({
@@ -107,7 +107,26 @@ function listTasks({ store, scheduler, collection, res, url }) {
     runningSince: scheduler.runningSince(t.id),
   }));
   const stats = store.getAggregatedStats();
-  sendJson(res, 200, { ok: true, tasks: list, recommendations: collection.recommendations, stats });
+  const payload = { ok: true, tasks: list, recommendations: collection.recommendations, stats };
+
+  // Calculate ETag based on payload JSON representation (#134)
+  const bodyString = JSON.stringify(payload);
+  const etag = 'W/"' + createHash('sha1').update(bodyString).digest('hex') + '"';
+
+  if (req && req.headers) {
+    const ifNoneMatch = req.headers['if-none-match'];
+    if (ifNoneMatch && (ifNoneMatch === etag || ifNoneMatch === etag.slice(2))) {
+      res.writeHead(304, { 'ETag': etag, 'Cache-Control': 'no-cache' });
+      res.end();
+      return;
+    }
+  }
+
+  if (typeof res.setHeader === 'function') {
+    res.setHeader('ETag', etag);
+    res.setHeader('Cache-Control', 'no-cache');
+  }
+  sendJson(res, 200, payload);
 }
 
 async function createOrUpdateTask({ store, scheduler, req, res }) {

package/lib/client.js

@@ -1035,11 +1035,29 @@ window.__ModuleLoader__.load({
         }
       };
 
+      const lastEtagRef = React.useRef('');
+
       React.useEffect(() => {
         fetchTasks();
-        const pollInterval = setInterval(() => {          // Background polling without resetting loading spinner
-          fetch('/dsh-cron/tasks?status=' + encodeURIComponent(tab) + '&query=' + encodeURIComponent(query))
-            .then(res => res.json())
+
+        let timerId = null;
+        let isDestroyed = false;
+
+        const doPoll = () => {
+          if (isDestroyed) return;
+          const headers = {};
+          if (lastEtagRef.current) headers['If-None-Match'] = lastEtagRef.current;
+
+          fetch('/dsh-cron/tasks?status=' + encodeURIComponent(tab) + '&query=' + encodeURIComponent(query), { headers })
+            .then(res => {
+              if (res.status === 304) {
+                // Not modified: skip parsing JSON
+                return null;
+              }
+              const etag = res.headers.get('ETag');
+              if (etag) lastEtagRef.current = etag;
+              return res.json();
+            })
             .then(data => {
               if (data && data.ok) {
                 setTasks(data.tasks || []);
@@ -1047,9 +1065,36 @@ window.__ModuleLoader__.load({
                 setStats(data.stats || null);
               }
             })
-            .catch(() => {});
-        }, 8000);
-        return () => clearInterval(pollInterval);
+            .catch(() => {})
+            .finally(() => {
+              if (isDestroyed) return;
+              // Adaptive interval: 30s when tab is hidden, 8s when active (#134)
+              const intervalMs = (typeof document !== 'undefined' && document.hidden) ? 30000 : 8000;
+              timerId = setTimeout(doPoll, intervalMs);
+            });
+        };
+
+        // Trigger immediate fetch when visibility returns
+        const onVisibilityChange = () => {
+          if (typeof document !== 'undefined' && !document.hidden) {
+            if (timerId) clearTimeout(timerId);
+            doPoll();
+          }
+        };
+
+        if (typeof document !== 'undefined') {
+          document.addEventListener('visibilitychange', onVisibilityChange);
+        }
+
+        timerId = setTimeout(doPoll, 8000);
+
+        return () => {
+          isDestroyed = true;
+          if (timerId) clearTimeout(timerId);
+          if (typeof document !== 'undefined') {
+            document.removeEventListener('visibilitychange', onVisibilityChange);
+          }
+        };
       }, [tab, query]);
       React.useEffect(() => { loadModels(); }, []);
 

package/lib/index.js

@@ -100,6 +100,7 @@ export const Config = z.object({
   giteaBaseUrl: z.string().default('').description('Gitea base URL for alert issues'),
   giteaRepo: z.string().default('').description('Gitea repository (owner/name) for alert issues'),
   giteaTokenRef: z.string().default('').description('Credential name for the Gitea API token'),
+  prReviewerEnabled: z.boolean().default(false).description('Enable automated PR Reviewer scheduled agent (#33)'),
   // --- Declarative jobs (#50, ADR-0001) ---
   // The array is intentionally permissive: each entry is validated on its own
   // with a precise message (see lib/config-jobs.js), so one broken entry cannot
@@ -122,7 +123,7 @@ export const SETTINGS_SYNC_KEYS = [
   'pushplusTokenRef',
   'pushplusUrl',
   'ttsBaseUrl',
-  'giteaBaseUrl', 'giteaRepo', 'giteaTokenRef',
+  'giteaBaseUrl', 'giteaRepo', 'giteaTokenRef', 'prReviewerEnabled',
   'apiToken',
 ];
 

package/lib/recipes.js

@@ -19,6 +19,7 @@ export const RECIPE_CATEGORIES = [
   { id: 'storage', title: 'Storage' },
   { id: 'security', title: 'Security' },
   { id: 'maintenance', title: 'Maintenance windows' },
+  { id: 'ci', title: 'CI & Code review' },
 ];
 
 /** Commands a recipe must never contain, checked by the test suite. */
@@ -190,6 +191,18 @@ export const RECIPES = [
     prompt: 'uptime && echo "---" && uname -r && echo "---" && df -h / | tail -n 1',
     channels: ['telegram'],
   },
+  {
+    id: 'recipe_pr_reviewer',
+    category: 'ci',
+    title: 'Autonomous PR Reviewer (#33)',
+    description: 'Periodic inspection of open Pull Requests in Gitea with agent review analysis.',
+    type: 'llm',
+    schedule: '*/30 * * * *',
+    scheduleText: 'Every 30 minutes',
+    prompt: 'Check open Pull Requests in Gitea repository. Inspect changed diffs, evaluate code quality, verify test coverage and post a concise review summary.',
+    channels: ['telegram', 'gitea'],
+    silentRule: 'Stay silent when there are no open PRs or no new commits to review.',
+  },
 ];
 
 /** Detached copy of the catalog, safe to hand to the UI. */

package/lib/runner.js

@@ -1,3 +1,18 @@
+/**
+ * Helper to test if an error code or status is transient and eligible for retry (#134).
+ */
+export function isTransientError(errOrStatus) {
+  if (typeof errOrStatus === 'number') {
+    return errOrStatus === 429 || errOrStatus === 502 || errOrStatus === 503 || errOrStatus === 504;
+  }
+  const str = String(errOrStatus?.message || errOrStatus || '').toLowerCase();
+  return str.includes('429') || str.includes('too many requests') ||
+         str.includes('502') || str.includes('bad gateway') ||
+         str.includes('503') || str.includes('service unavailable') ||
+         str.includes('504') || str.includes('gateway timeout') ||
+         str.includes('econnreset') || str.includes('etimedout');
+}
+
 import { estimateTokenCost } from './integrations.js';
 import {
   EXTERNAL_RUNTIMES,
@@ -99,24 +114,44 @@ export class SessionRunner {
     });
   }
 
-  /** HTTP trigger runtime (#7). */
+  /** HTTP trigger runtime (#7) with transient retry (#134). */
   async _runHttp(task, request, signal) {
-    const res = await fetch(request.url, {
-      method: request.method,
-      headers: request.headers,
-      body: request.body,
-      signal,
-    });
-    const text = await res.text().catch(() => '');
-    const summary = `${request.method} ${request.url} -> ${res.status} ${res.statusText || ''}`.trim();
-    if (!res.ok) {
-      throw new Error(`${summary}\n${String(text).slice(0, 500)}`);
+    let attempts = 0;
+    const maxAttempts = 3;
+    while (attempts < maxAttempts) {
+      attempts++;
+      try {
+        const res = await fetch(request.url, {
+          method: request.method,
+          headers: request.headers,
+          body: request.body,
+          signal,
+        });
+        const text = await res.text().catch(() => '');
+        const summary = `${request.method} ${request.url} -> ${res.status} ${res.statusText || ''}`.trim();
+        if (!res.ok) {
+          const err = new Error(`${summary}\n${String(text).slice(0, 500)}`);
+          if (isTransientError(res.status) && attempts < maxAttempts && !signal?.aborted) {
+            console.warn(`[dsh-cron] HTTP request returned ${res.status}, retrying attempt ${attempts + 1}/${maxAttempts}...`);
+            await new Promise((r) => setTimeout(r, attempts * 1000));
+            continue;
+          }
+          throw err;
+        }
+        return {
+          output: `${summary}\n${String(text).trim().slice(0, 4000)}`.trim(),
+          usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+          costUsd: 0,
+        };
+      } catch (err) {
+        if (isTransientError(err) && attempts < maxAttempts && !signal?.aborted) {
+          console.warn(`[dsh-cron] HTTP request failed (${err.message}), retrying attempt ${attempts + 1}/${maxAttempts}...`);
+          await new Promise((r) => setTimeout(r, attempts * 1000));
+          continue;
+        }
+        throw err;
+      }
     }
-    return {
-      output: `${summary}\n${String(text).trim().slice(0, 4000)}`.trim(),
-      usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
-      costUsd: 0,
-    };
   }
 
   /**
@@ -172,30 +207,89 @@ export class SessionRunner {
     const invocation = buildInvocation({ ...task, type: runtime }, cwd);
     if (invocation.http) return this._runHttp(task, invocation.http, signal);
 
-    const { exec, execFile } = await import('node:child_process');
+    const { spawn } = await import('node:child_process');
     return new Promise((resolve, reject) => {
-      const done = (err, stdout, stderr) => {
-        if (err) {
-          if (signal && signal.aborted) {
-            return reject(signal.reason || new Error('Command aborted'));
+      let child = null;
+      let settled = false;
+      let stdout = '';
+      let stderr = '';
+      const maxBuffer = 10 * 1024 * 1024;
+      const isPosix = process.platform !== 'win32';
+
+      const killProcessTree = (sig = 'SIGTERM') => {
+        if (!child || child.killed) return;
+        try {
+          if (isPosix && child.pid) {
+            try { process.kill(-child.pid, sig); } catch {}
+          } else if (child.pid) {
+            child.kill(sig);
           }
+        } catch {}
+      };
+
+      const abortHandler = () => {
+        killProcessTree('SIGTERM');
+        setTimeout(() => killProcessTree('SIGKILL'), 300);
+      };
+
+      if (signal) {
+        if (signal.aborted) {
+          return reject(signal.reason || new Error('Command aborted'));
+        }
+        signal.addEventListener('abort', abortHandler, { once: true });
+      }
+
+      const options = {
+        cwd,
+        env: invocation.env,
+        detached: isPosix,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      };
+
+      if (invocation.file) {
+        child = spawn(invocation.file, invocation.args || [], options);
+      } else {
+        const shellPath = isPosix ? (process.env.SHELL || '/bin/bash') : (process.env.ComSpec || 'cmd.exe');
+        const shellArgs = isPosix ? ['-c', invocation.shellCommand] : ['/d', '/s', '/c', invocation.shellCommand];
+        child = spawn(shellPath, shellArgs, options);
+      }
+
+      child.stdout.on('data', (chunk) => {
+        if (stdout.length < maxBuffer) stdout += chunk;
+      });
+      child.stderr.on('data', (chunk) => {
+        if (stderr.length < maxBuffer) stderr += chunk;
+      });
+
+      child.on('error', (err) => {
+        if (settled) return;
+        settled = true;
+        if (signal) signal.removeEventListener('abort', abortHandler);
+        reject(err);
+      });
+
+      child.on('close', (code, sig) => {
+        if (settled) return;
+        settled = true;
+        if (signal) signal.removeEventListener('abort', abortHandler);
+
+        if (signal && signal.aborted) {
+          return reject(signal.reason || new Error('Command aborted'));
+        }
+
+        if (code !== 0 && code !== null) {
           const detail = String(stderr || '').trim();
-          return reject(new Error(detail ? `${err.message}\n${detail}` : err.message));
+          const msg = `${runtime} task exited with code ${code}`;
+          return reject(new Error(detail ? `${msg}\n${detail}` : msg));
         }
+
         const out = (stdout || stderr || '').trim();
         resolve({
           output: out || `${runtime} task completed with code 0`,
           usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
           costUsd: 0,
         });
-      };
-      const options = { cwd, signal, maxBuffer: 10 * 1024 * 1024, env: invocation.env };
-      if (invocation.file) {
-        execFile(invocation.file, invocation.args || [], options, done);
-      } else {
-        const shellPath = process.platform === 'win32' ? undefined : (process.env.SHELL || '/bin/bash');
-        exec(invocation.shellCommand, { ...options, shell: shellPath }, done);
-      }
+      });
     });
   }
 

package/lib/scheduler.js

@@ -169,7 +169,7 @@ export class TaskScheduler {
   constructor(store, executeFn, options = {}) {
     this.store = store;
     this.executeFn = executeFn;
-    this.maxConcurrent = Number(options.maxConcurrent) > 0 ? Number(options.maxConcurrent) : 0; // 0 = unlimited (#52)
+    this.maxConcurrent = options.maxConcurrent !== undefined && Number(options.maxConcurrent) >= 0 ? Number(options.maxConcurrent) : 2; // default 2 parallel runs (#134, #52)
     this.defaultTimezone = options.defaultTimezone || ''; // #13
     this.resolveSecrets = typeof options.resolveSecrets === 'function' ? options.resolveSecrets : null; // #51
     this.deliver = typeof options.deliver === 'function' ? options.deliver : null; // #26 channel router

package/lib/store.js

@@ -295,11 +295,41 @@ export class TaskStore {
       suggestion: runInfo.suggestion ? String(runInfo.suggestion).slice(0, 2000) : '',
       confidence: runInfo.confidence || '',
     });
-    if (runs.length > 50) runs.length = 50;
+    // Keep up to 100 runs in active store; archive older runs to tasks-history-archive.json (#134)
+    if (runs.length > 100) {
+      const overflow = runs.splice(100);
+      this._archiveHistoryRuns(id, overflow);
+    }
     this.history.set(id, runs);
     this.save();
   }
 
+  /**
+   * Append rotated overflow history entries into tasks-history-archive.json (#134).
+   */
+  _archiveHistoryRuns(id, overflowRuns) {
+    if (!Array.isArray(overflowRuns) || overflowRuns.length === 0) return;
+    try {
+      const dir = path.dirname(this.filePath);
+      const archivePath = path.join(dir, 'tasks-history-archive.json');
+      let archive = {};
+      if (fs.existsSync(archivePath)) {
+        try {
+          archive = JSON.parse(fs.readFileSync(archivePath, 'utf-8')) || {};
+        } catch {}
+      }
+      if (!Array.isArray(archive[id])) archive[id] = [];
+      archive[id].push(...overflowRuns);
+      // Write atomically with tmp file
+      const rand = Math.random().toString(36).slice(2, 8);
+      const tmp = `${archivePath}.tmp.${process.pid}_${Date.now()}_${rand}`;
+      fs.writeFileSync(tmp, JSON.stringify(archive, null, 2), 'utf-8');
+      fs.renameSync(tmp, archivePath);
+    } catch (archiveErr) {
+      console.error('[dsh-cron] history archive error:', archiveErr.message);
+    }
+  }
+
   getHistory(id, limit = 20) {
     const runs = this.history.get(id) || [];
     return runs.slice(0, limit);

package/package.json

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