@goodandready/dsh-cron 0.2.47 → 0.2.48

package/lib/api.js

@@ -547,7 +547,7 @@ export async function handleExternalTaskRequest({ store, scheduler, req, res, ur
   }
 
   if (req.method === 'POST') {
-    const handled = await handleItemPost({ store, scheduler, req, res, url, id, action, apiToken });
+    const handled = await handleItemPost({ store, scheduler, req, res, url, id, action });
     if (handled) return;
   }
   if (req.method === 'GET' && !action) {

package/lib/channels.js

@@ -153,14 +153,27 @@ export function buildGiteaIssuePayload({ task, runInfo, settings = {} }) {
   const failed = isFailed(runInfo.status);
   const defaultNames = failed ? ['cron', 'bug', 'alert'] : ['cron', 'auto'];
 
-  // Resolve labels to integer IDs per Gitea Swagger (array<int64>) (#224)
-  const mapping = settings.giteaLabelIds || {};
+  // Resolve labels to integer IDs per Gitea Swagger (array<int64>) (#224, #297)
+  let mapping = settings.giteaLabelIds || {};
+  if (typeof mapping === 'string' && mapping.trim().startsWith('{')) {
+    try {
+      mapping = JSON.parse(mapping);
+    } catch (_) {
+      mapping = {};
+    }
+  }
   let candidateIds = [];
 
   if (Array.isArray(task && task.giteaLabelIds)) {
     candidateIds = task.giteaLabelIds;
   } else if (Array.isArray(settings.giteaLabels)) {
     candidateIds = settings.giteaLabels;
+  } else if (typeof settings.giteaLabels === 'string' && settings.giteaLabels.trim()) {
+    candidateIds = settings.giteaLabels.split(',').map((s) => s.trim()).filter(Boolean).map((name) => {
+      const num = Number(name);
+      if (Number.isInteger(num) && num > 0) return num;
+      return typeof mapping === 'object' && mapping !== null ? mapping[name] : undefined;
+    });
   } else if (Array.isArray(settings.giteaLabelIds)) {
     candidateIds = settings.giteaLabelIds;
   } else if (Array.isArray(task && task.labels)) {

package/lib/config-jobs.js

@@ -17,6 +17,7 @@ import { parseScheduleExpression } from './scheduler.js';
 import { unknownChannelIds } from './channels.js';
 import { PATCHABLE_TASK_FIELDS, validateTaskType } from './task-transfer.js';
 import { pickPatchableFields } from './http-utils.js';
+import { logger } from './logger.js';
 
 /** Marker that makes a task owned by the config (#50). */
 export const MANAGED_BY_CONFIG = 'config';
@@ -171,7 +172,7 @@ export function planConfigSync(entries, existingTasks) {
  * Apply the plan: create, update and remove tasks, then arm or pause them.
  * Never throws for a single bad entry — that entry is reported and skipped.
  */
-export function applyConfigSync({ store, scheduler, entries, log = console }) {
+export function applyConfigSync({ store, scheduler, entries, log = logger }) {
   const plan = planConfigSync(entries, store.list({ status: 'all' }));
   for (const warning of plan.warnings) log.warn('[dsh-cron] config jobs: ' + warning);
   for (const entry of plan.skipped) log.error('[dsh-cron] config jobs: skipped: ' + entry.error);

package/lib/cron-tool.js

@@ -3,6 +3,7 @@ import { applyTaskPatch, describeTaskPatch } from './task-patch.js';
 import { isConfigOwned, configOwnedMessage } from './config-jobs.js';
 import { TASK_TYPES } from './runtimes.js';
 import { CHANNEL_IDS } from './channels.js';
+import { redactTaskSecrets } from './http-utils.js';
 
 export const LEGACY_TOOL_NAMES = [
   'cron_create_task',
@@ -394,7 +395,7 @@ export async function executeCronTool(store, scheduler, args = {}) {
         `channels: ${Array.isArray(task.channels) && task.channels.length ? task.channels.join(', ') : '(legacy flags)'}`,
         `prompt: ${String(task.prompt || '').slice(0, 500)}`,
       ].filter(Boolean).join('\n');
-      return { success: true, message: summary, task };
+      return { success: true, message: summary, task: redactTaskSecrets(task) };
     }
 
     case 'update': {
@@ -411,7 +412,7 @@ export async function executeCronTool(store, scheduler, args = {}) {
       return {
         success: true,
         message: `Task "${result.task.title}" updated (${result.task.scheduleText || result.task.schedule}). Changed: ${describeTaskPatch(result.task, result.patch)}`,
-        task: result.task,
+        task: redactTaskSecrets(result.task),
       };
     }
 

package/lib/http-utils.js

@@ -94,15 +94,17 @@ export function isTrustedRequest(req, options = {}) {
 
   const remote = req.socket?.remoteAddress || req.connection?.remoteAddress;
   const hasRemote = Boolean(remote && typeof remote === 'string');
-  const isLoopback = !hasRemote || isLoopbackAddress(remote);
+  const isLoopback = Boolean(hasRemote && isLoopbackAddress(remote));
 
   const token = extractBearerToken(req);
   const expectedToken = options.apiToken || process.env.DSH_AUTH_TOKEN || process.env.DSH_TOKEN;
   const isTokenAuthenticated = Boolean(expectedToken && token && token === expectedToken);
 
-  // 1. Non-loopback remote addresses require explicit token authentication (#86)
-  if (hasRemote && !isLoopback && !isTokenAuthenticated) {
-    return false;
+  // 1. Non-loopback socket callers (or callers with missing remoteAddress) require explicit token authentication (#86, #295)
+  if (req.socket || req.connection || hasRemote) {
+    if (!isLoopback && !isTokenAuthenticated) {
+      return false;
+    }
   }
 
   // 2. Validate Origin header if present: cannot be null, must match Host

package/lib/index.js

@@ -117,22 +117,20 @@ export {
   LEGACY_ACTION_MAP,
 };
 const pkgUrl = new URL('../package.json', import.meta.url);
-// Helper to access configuration safely in native Cordis Context without throwing missing-inject error (#235)
-function getContextConfig(ctx, rawConfig) {
+// Helper to access configuration safely in native Cordis Context without throwing missing-inject error (#235, #288)
+export function getContextConfig(ctx, rawConfig) {
   try {
     if (ctx && ctx.fiber && ctx.fiber.config) return ctx.fiber.config;
     if (ctx && ctx.scope && ctx.scope.config) return ctx.scope.config;
     if (ctx && ctx.runtime && ctx.runtime.config) return ctx.runtime.config;
-    if (ctx && typeof ctx === 'object' && 'config' in ctx) {
-      try {
-        const c = ctx.config;
-        if (c) return c;
-      } catch (err) {
-        // Ignore missing inject error on native Cordis Context (#235)
-      }
+    // In plain/mock contexts without fiber/scope, safely attempt reading config
+    try {
+      if (ctx && ctx.config) return ctx.config;
+    } catch (_) {
+      // Ignored if ctx is a Cordis proxy throwing without inject (#235, #288)
     }
   } catch (err) {
-    // Ignore context access error and fall back to rawConfig (#235)
+    // Ignore context access error and fall back to rawConfig (#235, #288)
   }
   return rawConfig || {};
 }
@@ -199,7 +197,7 @@ export function apply(ctx, rawConfig) {
   // A broken entry is reported and skipped, never fatal.
   try {
     const configJobs = Array.isArray(config && config.jobs) ? config.jobs : [];
-    const summary = applyConfigSync({ store, scheduler, entries: configJobs });
+    const summary = applyConfigSync({ store, scheduler, entries: configJobs, log: logger });
     logger.info('[dsh-cron] config jobs synced: ' + JSON.stringify(summary));
   } catch (err) {
     logger.error('[dsh-cron] config job sync failed:', err.message);
@@ -253,7 +251,7 @@ export function apply(ctx, rawConfig) {
       }
       const current = store.getSettings();
       const patch = {};
-      for (const k of ['maxConcurrent', 'defaultTimezone', 'heartbeatUrl', 'heartbeatIntervalSec', 'llmActionsEnabled']) {
+      for (const k of SETTINGS_SYNC_KEYS) {
         if (unwrapped[k] !== undefined && unwrapped[k] !== current[k]) {
           patch[k] = unwrapped[k];
         }
@@ -295,7 +293,6 @@ export function apply(ctx, rawConfig) {
   registerRoutes(ctx, {
     store,
     scheduler,
-    getCronSettingsScope: () => settingsService,
     recommendations,
   });
 
@@ -311,7 +308,7 @@ export function apply(ctx, rawConfig) {
             ...activeVolatileConfig,
           };
           const clientSettings = store.getClientSettings();
-          for (const k of ['maxConcurrent', 'defaultTimezone', 'heartbeatUrl', 'heartbeatIntervalSec', 'llmActionsEnabled']) {
+          for (const k of SETTINGS_SYNC_KEYS) {
             if (unwrapped[k] !== undefined) {
               clientSettings[k] = unwrapped[k];
             }

package/lib/routes.js

@@ -10,7 +10,7 @@ import { sendTelegramMessage, createTelegramTaskKeyboard } from './telegram.js';
 import { createKanbanCard } from './integrations.js';
 import { sanitizeSettingsPayload, applySettingsToScope } from './settings.js';
 
-export function registerRoutes(ctx, { store, scheduler, getCronSettingsScope, recommendations }) {
+export function registerRoutes(ctx, { store, scheduler, recommendations }) {
   // handler per route family; registered WITHOUT the trailing slash (#96)
   ctx.effect(() => ctx.webServer.register({
     kind: 'prefix',

package/lib/scheduler-execution.js

@@ -40,15 +40,17 @@ export async function executePreflight(task) {
   }
 
   if (type === 'http') {
+    let timeout;
     try {
       const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), 5000);
+      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}` };
+    } finally {
+      if (timeout) clearTimeout(timeout);
     }
   }
 
@@ -595,7 +597,7 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
   const guard = await checkAndApplyBurnGuard(scheduler, taskId, outcome);
   if (guard && guard.exceeded) return;
 
-  while (!scheduler.isStopped && scheduler.queue.length > 0 && (scheduler.maxConcurrent === 0 || scheduler.running.size < scheduler.maxConcurrent)) {
+  if (!scheduler.isStopped && scheduler.queue.length > 0 && (scheduler.maxConcurrent === 0 || scheduler.running.size < scheduler.maxConcurrent)) {
     let admittedIndex = -1;
     for (let i = 0; i < scheduler.queue.length; i++) {
       const candidate = scheduler.queue[i];
@@ -619,17 +621,16 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
       break;
     }
 
-    if (admittedIndex === -1) break;
-
-    const nextItem = scheduler.queue.splice(admittedIndex, 1)[0];
-    setImmediate(() => {
-      if (!scheduler.isStopped) {
-        scheduler.runTask(nextItem.taskId, nextItem.options || {}).catch((runErr) => {
-          bestEffort('drain-queued-task', () => {}, scheduler.logger);
-        });
-      }
-    });
-    break;
+    if (admittedIndex !== -1) {
+      const nextItem = scheduler.queue.splice(admittedIndex, 1)[0];
+      setImmediate(() => {
+        if (!scheduler.isStopped) {
+          scheduler.runTask(nextItem.taskId, nextItem.options || {}).catch((runErr) => {
+            bestEffort('drain-queued-task', () => {}, scheduler.logger);
+          });
+        }
+      });
+    }
   }
 
   // 1. Structured LLM Actions (#137)

package/lib/scheduler.js

@@ -140,15 +140,17 @@ function parseIntervalExpression(str) {
     if (num >= 60) {
       if (num % 60 === 0) {
         const hours = num / 60;
-        if (hours >= 24 && hours % 24 === 0) {
-          const days = hours / 24;
-          if (days > 31) {
-            throw new Error(`Invalid interval: minute interval "${num}m" (${days} days) exceeds 31 days`);
+        if (hours >= 24) {
+          if (hours % 24 === 0) {
+            const days = hours / 24;
+            if (days > 31) {
+              throw new Error(`Invalid interval: minute interval "${num}m" (${days} days) exceeds 31 days`);
+            }
+            pattern = `0 0 */${days} * *`;
+            humanText = `Every ${days} days`;
+          } else {
+            throw new Error(`Invalid interval: minute interval "${num}m" (${hours} hours) cannot be expressed as a cron step`);
           }
-          pattern = `0 0 */${days} * *`;
-          humanText = `Every ${days} days`;
-        } else if (hours > 23) {
-          throw new Error(`Invalid interval: minute interval "${num}m" (${hours} hours) cannot be expressed as a cron step`);
         } else {
           pattern = `0 */${hours} * * *`;
           humanText = `Every ${hours} hours`;

package/lib/settings.js

@@ -44,6 +44,8 @@ export const Config = z.object({
   giteaBaseUrl: z.string().default('').description('Gitea base URL for alert issues').volatile(),
   giteaRepo: z.string().default('').description('Gitea repository (owner/name) for alert issues').volatile(),
   giteaTokenRef: z.string().default('').description('Credential name for the Gitea API token').volatile(),
+  giteaLabels: z.any().default([]).description('Gitea label names or IDs for alert issues').volatile(),
+  giteaLabelIds: z.any().default({}).description('Mapping of label name to integer ID for Gitea issues').volatile(),
   prReviewerEnabled: z.boolean().default(false).description('Enable automated PR Reviewer scheduled agent (#33)').volatile(),
   // --- Declarative jobs (#50, ADR-0001) ---
   jobs: z.array(z.any()).default([]).description('Static jobs owned by the config; each entry needs id, title, schedule and (for agent types) prompt'),
@@ -79,7 +81,7 @@ export const SETTINGS_SYNC_KEYS = [
   'pushplusTokenRef',
   'pushplusUrl',
   'ttsBaseUrl',
-  'giteaBaseUrl', 'giteaRepo', 'giteaTokenRef', 'prReviewerEnabled',
+  'giteaBaseUrl', 'giteaRepo', 'giteaTokenRef', 'giteaLabels', 'giteaLabelIds', 'prReviewerEnabled',
   'apiToken',
 ];
 

package/lib/task-create.js

@@ -2,6 +2,7 @@ import { normalizeTaskType } from './runtimes.js';
 import { validateTaskType } from './task-transfer.js';
 import { parseScheduleExpression } from './scheduler.js';
 import { CHANNEL_IDS } from './channels.js';
+import { redactTaskSecrets } from './http-utils.js';
 
 export function executeCreateTask(store, scheduler, args) {
   const taskType = normalizeTaskType(args.type);
@@ -76,7 +77,7 @@ export function executeCreateTask(store, scheduler, args) {
   return {
     success: true,
     message: `Task "${task.title}" scheduled successfully (${task.scheduleText})`,
-    task
+    task: redactTaskSecrets(task),
   };
 }
 

package/lib/task-patch.js

@@ -22,23 +22,27 @@ export function isCodeTypeSwitch(current, nextType) {
   return CODE_EXECUTING_TYPES.includes(target) && !CODE_EXECUTING_TYPES.includes(current.type);
 }
 
-/** True when a patch introduces code-executing type or shell hooks (#212). */
+/** True when a patch introduces code-executing type or shell hooks (#212, #296). */
 export function isCodeExecutionIntroduced(current, body) {
   if (!current || !body) return false;
   if (body.type !== undefined && isCodeTypeSwitch(current, body.type)) return true;
 
-  const hadPreflight = Boolean(current.preflightCommand && String(current.preflightCommand).trim()) || current.preflightType === 'command' || current.preflightType === 'shell';
-  const hasPreflight = Boolean(body.preflightCommand && String(body.preflightCommand).trim()) || body.preflightType === 'command' || body.preflightType === 'shell';
+  const isShellPreflight = (t) => t === 'command' || t === 'shell';
+  const currentPreflightType = current.preflightType || 'none';
+  const nextPreflightType = body.preflightType !== undefined ? body.preflightType : currentPreflightType;
+
+  const currentPreflightTarget = current.preflightTarget || current.preflightCommand || '';
+  const bodyPreflightTarget = body.preflightTarget !== undefined ? body.preflightTarget : (body.preflightCommand !== undefined ? body.preflightCommand : '');
+  const nextPreflightTarget = (body.preflightTarget !== undefined || body.preflightCommand !== undefined) ? bodyPreflightTarget : currentPreflightTarget;
+
+  const hadPreflight = isShellPreflight(currentPreflightType) && Boolean(String(currentPreflightTarget).trim());
+  const hasPreflight = isShellPreflight(nextPreflightType) && Boolean(String(nextPreflightTarget).trim());
   if (hasPreflight && !hadPreflight) return true;
 
   const hadSelfHealing = Boolean(current.selfHealingCommand && String(current.selfHealingCommand).trim());
   const hasSelfHealing = Boolean(body.selfHealingCommand && String(body.selfHealingCommand).trim());
   if (hasSelfHealing && !hadSelfHealing) return true;
 
-  const hadCommand = Boolean(current.command && String(current.command).trim());
-  const hasCommand = Boolean(body.command && String(body.command).trim());
-  if (hasCommand && !hadCommand && !CODE_EXECUTING_TYPES.includes(current.type)) return true;
-
   return false;
 }
 

package/package.json

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