@goodandready/dsh-cron 0.2.39 → 0.2.41

package/lib/api-import-export.js

@@ -15,9 +15,18 @@ import {
 } from './http-utils.js';
 import { MANAGED_BY_CONFIG } from './config-jobs.js';
 
-export function handleTaskExport({ store, res }) {
-  const doc = buildTaskExport(store.list({ status: 'all' }));
-  sendJson(res, 200, { ok: true, document: doc, count: doc.tasks.length });
+export function handleTaskExport({ store, req, res }) {
+  let sanitize = false;
+  if (req && req.url) {
+    try {
+      const parsed = new URL(req.url, 'http://127.0.0.1');
+      sanitize = parsed.searchParams.get('sanitize') === 'true' || parsed.searchParams.get('redact') === 'true';
+    } catch (urlErr) {
+      logger.debug('[dsh-cron] export url parse fallback:', urlErr.message);
+    }
+  }
+  const doc = buildTaskExport(store.list({ status: 'all' }), { sanitize });
+  sendJson(res, 200, { ok: true, document: doc, count: doc.tasks.length, sanitized: sanitize });
 }
 
 export async function handleTaskImport({ store, scheduler, req, res }) {

package/lib/api.js

@@ -101,7 +101,7 @@ export function createCronApiHandler(store, scheduler, collection) {
           sendJson(res, 405, NOT_ALLOWED);
           return;
         }
-        handleTaskExport({ store, res });
+        handleTaskExport({ store, req, res });
         return;
       }
       if (id === 'import') {
@@ -256,8 +256,8 @@ function buildTaskRecord(store, body, taskType, parsed) {
     model: body.model || undefined,
     fallbackProvider: body.fallbackProvider || undefined,
     fallbackModel: body.fallbackModel || undefined,
-    notifyTelegram: body.notifyTelegram !== undefined ? Boolean(body.notifyTelegram) : (current ? current.notifyTelegram : false),
-    onlyOnFailure: body.onlyOnFailure !== undefined ? Boolean(body.onlyOnFailure) : (current ? current.onlyOnFailure : false),
+    notifyTelegram: body.notifyTelegram !== undefined ? Boolean(body.notifyTelegram) : (current ? current.notifyTelegram : undefined),
+    onlyOnFailure: body.onlyOnFailure !== undefined ? Boolean(body.onlyOnFailure) : (current ? current.onlyOnFailure : undefined),
     timeoutSeconds: body.timeoutSeconds !== undefined ? Number(body.timeoutSeconds) : (current ? current.timeoutSeconds : 1800),
     overlapPolicy: body.overlapPolicy || (current ? current.overlapPolicy : 'skip'),
     kanbanMode: body.kanbanMode || (current ? current.kanbanMode : 'none'),

package/lib/channels.js

@@ -18,11 +18,17 @@ export const CHANNEL_IDS = ['telegram', 'kanban', 'discord', 'slack', 'ntfy', 'b
 export const isFailureStatus = (status) => status === 'error' || status === 'timeout' || status === 'missed';
 export const isFailed = (status) => isFailureStatus(status);
 
-/** The message text for a channel: custom template, else built-in defaults. */
-function messageTextFor(channelId, task, runInfo, settings = {}) {
+/** The message text for a channel: task template -> channel template -> global template -> built-in defaults (#233). */
+export function messageTextFor(channelId, task, runInfo, settings = {}) {
   const templates = (settings && settings.channelTemplates) || {};
-  const template = templates[channelId] || settings.template || '';
-  return resolveTemplateText({ template, task, runInfo });
+  const custom = (task && task.template) || templates[channelId] || (settings && settings.template) || '';
+  if (custom) {
+    return resolveTemplateText({ template: custom, task, runInfo });
+  }
+  if (channelId === 'telegram') {
+    return formatTaskTelegramMessage(task, runInfo);
+  }
+  return resolveTemplateText({ template: '', task, runInfo });
 }
 
 /**
@@ -56,17 +62,27 @@ export function unknownChannels(task) {
   return unknownChannelIds(task && task.channels);
 }
 
-/** Failure/only-on-failure filtering, per channel. */
+/** Failure/only-on-failure filtering, per channel (#219). Explicit task channels win over legacy flags. */
 export function shouldSendToChannel(channelId, task, runInfo, settings = {}) {
-  if (channelId === 'kanban') return shouldCreateKanbanCard(task, runInfo);
-  if (channelId === 'telegram') {
-    if (task && task.notifyTelegram === false) return false;
-    const taskForTelegram = Object.assign({}, task, { notifyTelegram: true });
-    return shouldNotifyTask(taskForTelegram, runInfo, settings);
+  const isExplicit = Array.isArray(task && task.channels) && task.channels.includes(channelId);
+  if (!isExplicit) {
+    if (channelId === 'kanban') return shouldCreateKanbanCard(task, runInfo);
+    if (channelId === 'telegram') {
+      if (task && task.notifyTelegram === false) return false;
+      const taskForTelegram = Object.assign({}, task, { notifyTelegram: true });
+      return shouldNotifyTask(taskForTelegram, runInfo, settings);
+    }
+  }
+
+  // Explicit selection (or default event filtering for all channels):
+  if (channelId === 'kanban') {
+    if (task && task.kanbanMode === 'on_failure') return isFailed(runInfo.status);
+    if (task && task.kanbanMode === 'always') return true;
   }
-  const onlyOnFail = task.onlyOnFailure !== undefined
+
+  const onlyOnFail = (task && task.onlyOnFailure !== undefined)
     ? Boolean(task.onlyOnFailure)
-    : Boolean(settings.onlyOnFailure);
+    : Boolean(settings && settings.onlyOnFailure);
   if (onlyOnFail && !isFailed(runInfo.status)) return false;
   return true;
 }
@@ -133,8 +149,34 @@ export function buildPushplusRequest({ settings = {}, text, task, token }) {
   };
 }
 
-export function buildGiteaIssuePayload({ task, runInfo }) {
+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 || {};
+  let candidateIds = [];
+
+  if (Array.isArray(task && task.giteaLabelIds)) {
+    candidateIds = task.giteaLabelIds;
+  } else if (Array.isArray(settings.giteaLabels)) {
+    candidateIds = settings.giteaLabels;
+  } else if (Array.isArray(settings.giteaLabelIds)) {
+    candidateIds = settings.giteaLabelIds;
+  } else if (Array.isArray(task && task.labels)) {
+    candidateIds = task.labels.map((item) => {
+      const num = Number(item);
+      if (Number.isInteger(num) && num > 0) return num;
+      return typeof mapping === 'object' && mapping !== null ? mapping[item] : undefined;
+    });
+  } else if (typeof mapping === 'object' && mapping !== null && Object.keys(mapping).length > 0) {
+    candidateIds = defaultNames.map((name) => mapping[name]);
+  }
+
+  const labelIds = candidateIds
+    .map((id) => Number(id))
+    .filter((id) => Number.isInteger(id) && id > 0);
+
   return {
     title: `${failed ? '[Cron failure]' : '[Cron run]'} ${truncateText(task.title || 'Task', 200)}`,
     body: [
@@ -145,7 +187,7 @@ export function buildGiteaIssuePayload({ task, runInfo }) {
       runInfo.error ? `\n**Error:**\n\`\`\`\n${truncateText(runInfo.error, 1000)}\n\`\`\`` : '',
       runInfo.output ? `\n**Output:**\n\`\`\`\n${truncateText(runInfo.output, 1000)}\n\`\`\`` : '',
     ].filter(Boolean).join('\n\n'),
-    labels: failed ? ['cron', 'bug', 'alert'] : ['cron', 'auto'],
+    labels: labelIds,
   };
 }
 
@@ -248,9 +290,7 @@ const CHANNEL_HANDLERS = {
     const botToken = secrets.botToken || '';
     const chatId = String(settings.chatId || '').trim();
     if (!botToken || !chatId) throw new Error('telegram: botToken or chatId is not configured');
-    const text = settings.template
-      ? messageTextFor('telegram', task, runInfo, settings)
-      : formatTaskTelegramMessage(task, runInfo);
+    const text = messageTextFor('telegram', task, runInfo, settings);
     try {
       const replyMarkup = createTelegramTaskKeyboard(task, runInfo);
       await sendTelegramMessage({ botToken, chatId, text, replyMarkup, fetchFn: http, signal });
@@ -321,7 +361,7 @@ const CHANNEL_HANDLERS = {
     if (!base || !repo) throw new Error('gitea: giteaBaseUrl and giteaRepo are required');
     const token = settings.giteaTokenRef ? await resolveSecret(settings.giteaTokenRef) : '';
     if (!token) throw new Error(`gitea: credential "${settings.giteaTokenRef || ''}" did not resolve`);
-    const payload = buildGiteaIssuePayload({ task, runInfo });
+    const payload = buildGiteaIssuePayload({ task, runInfo, settings });
     const issue = await postJson(
       http,
       `${base}/api/v1/repos/${repo}/issues`,

package/lib/client.js

@@ -88,7 +88,8 @@ window.__ModuleLoader__.load({
         'transfer.exported': 'Exported {count} task(s).',
         'transfer.exportFailed': 'Export failed: {error}',
         'transfer.importTitleModal': 'Import tasks',
-        'transfer.importHint': 'Exported task configuration only: no run history, no counters. Secrets are not included — channels reference credentials by name, so make sure those credential names exist on the target harness.',
+        'transfer.importHint': 'Exported task configuration only: no run history, no counters. Channel configurations reference credentials by name; note that raw exports retain custom env variables and HTTP request headers.',
+        'transfer.exportPrompt': 'Choose export mode:\nOK = Sanitized (removes custom env vars & headers)\nCancel = Full raw export',
         'transfer.strategyAdd': 'Add as new tasks (new ids, existing ones stay untouched)',
         'transfer.strategyReplace': 'Replace tasks with the same id',
         'transfer.strategySkip': 'Skip tasks whose id already exists',
@@ -390,7 +391,8 @@ window.__ModuleLoader__.load({
         'transfer.exported': '已成功导出 {count} 个任务。',
         'transfer.exportFailed': '导出失败: {error}',
         'transfer.importTitleModal': '导入任务',
-        'transfer.importHint': '仅导出任务静态配置：不包含历史记录与计数器。不包含密钥——渠道通过凭据名称引用。',
+        'transfer.importHint': '仅导出任务静态配置：不包含历史记录与计数器。渠道通过凭据名称引用；注意完整导出保留自定义环境变量和 HTTP 请求头。',
+        'transfer.exportPrompt': '请选择导出模式：\n确定 = 净化导出（移除自定义环境变量与请求头）\n取消 = 完整原始导出',
         'transfer.strategyAdd': '作为新任务导入（分配新 ID）',
         'transfer.strategyReplace': '覆盖同 ID 任务',
         'transfer.strategySkip': '跳过已存在的同 ID 任务',
@@ -1383,12 +1385,16 @@ window.__ModuleLoader__.load({
         setTimeout(() => { try { node.classList.remove('dsh-cron-task-highlight'); } catch (err) { /* node unmounted */ } }, 2500);
       }, [tasks]);
 
+      const fetchGenRef = React.useRef(0);
+
       const fetchTasks = async () => {
+        const gen = ++fetchGenRef.current;
         setLoading(true);
         setFetchError(null);
         try {
           const res = await fetch('/dsh-cron/tasks?status=' + encodeURIComponent(tab) + '&query=' + encodeURIComponent(query));
           const data = await res.json();
+          if (gen !== fetchGenRef.current) return;
           if (data && data.ok) {
             setTasks(data.tasks || []);
             setRecs(data.recommendations || []);
@@ -1397,10 +1403,13 @@ window.__ModuleLoader__.load({
             setFetchError(data && data.error ? data.error : T_KEY(t, 'list.loadErrorPrefix'));
           }
         } catch (err) {
+          if (gen !== fetchGenRef.current) return;
           console.error('[dsh-cron] fetch tasks error:', err);
           setFetchError(err.message || T_KEY(t, 'list.loadErrorPrefix'));
         } finally {
-          setLoading(false);
+          if (gen === fetchGenRef.current) {
+            setLoading(false);
+          }
         }
       };
 
@@ -1488,22 +1497,50 @@ window.__ModuleLoader__.load({
       }, [tab, query]);
       React.useEffect(() => { loadModels(); }, []);
 
+      const actionInProgressRef = React.useRef(new Set());
+
       const handleToggleTask = async (id) => {
+        if (actionInProgressRef.current.has(id)) return;
+        actionInProgressRef.current.add(id);
         try {
-          await fetch('/dsh-cron/tasks/' + encodeURIComponent(id) + '/toggle', { method: 'POST' });
-          fetchTasks();
+          const res = await fetch('/dsh-cron/tasks/' + encodeURIComponent(id) + '/toggle', { method: 'POST' });
+          const data = await res.json().catch(() => ({}));
+          if (!res.ok || (data && data.ok === false)) {
+            const msg = (data && data.error) || `Toggle failed (HTTP ${res.status})`;
+            alert(msg);
+            return;
+          }
+          await fetchTasks();
         } catch (err) {
-          console.debug('[dsh-cron] toggle failed', err);
+          console.error('[dsh-cron] toggle failed', err);
+          alert('Toggle request failed: ' + err.message);
+        } finally {
+          actionInProgressRef.current.delete(id);
         }
       };
 
       const handleRunNow = async (id) => {
+        if (actionInProgressRef.current.has(id)) return;
+        actionInProgressRef.current.add(id);
+        const prevTask = tasks.find(t => t.id === id);
+        const prevStatus = prevTask ? prevTask.lastStatus : null;
+        setTasks(prev => prev.map(t2 => t2.id === id ? { ...t2, lastStatus: 'running' } : t2));
         try {
-          setTasks(prev => prev.map(t2 => t2.id === id ? { ...t2, lastStatus: 'running' } : t2));
-          await fetch('/dsh-cron/tasks/' + encodeURIComponent(id) + '/run', { method: 'POST' });
+          const res = await fetch('/dsh-cron/tasks/' + encodeURIComponent(id) + '/run', { method: 'POST' });
+          const data = await res.json().catch(() => ({}));
+          if (!res.ok || (data && data.ok === false)) {
+            setTasks(prev => prev.map(t2 => t2.id === id ? { ...t2, lastStatus: prevStatus } : t2));
+            const msg = (data && data.error) || `Run failed (HTTP ${res.status})`;
+            alert(msg);
+            return;
+          }
           setTimeout(() => fetchTasks(), 1500);
         } catch (err) {
           console.error('[dsh-cron] run now error:', err);
+          setTasks(prev => prev.map(t2 => t2.id === id ? { ...t2, lastStatus: prevStatus } : t2));
+          alert('Run request failed: ' + err.message);
+        } finally {
+          actionInProgressRef.current.delete(id);
         }
       };
 
@@ -1527,7 +1564,7 @@ window.__ModuleLoader__.load({
           const res = await fetch('/dsh-cron/tasks/' + encodeURIComponent(task.id) + '/archive?limit=15&offset=' + offset);
           const data = await res.json();
           if (data.ok) {
-            setArchiveRuns(data.runs || []);
+            setArchiveRuns(prev => offset === 0 ? (data.runs || []) : [...prev, ...(data.runs || [])]);
             setArchiveTotal(data.total || 0);
           }
         } catch (err) {
@@ -1592,11 +1629,14 @@ window.__ModuleLoader__.load({
         return headers;
       };
 
-      /** #42: download the task configuration as a JSON file. */
+      /** #42, #240: download the task configuration with honest disclosure and sanitized export choice. */
       const handleExport = async () => {
         setTransferBusy(true);
         try {
-          const res = await fetch('/dsh-cron/tasks/export');
+          const promptMsg = T_KEY(t, 'transfer.exportPrompt') || 'Choose export mode:\nOK = Sanitized (removes custom env vars & headers)\nCancel = Full raw export';
+          const wantSanitized = confirm(promptMsg);
+          const exportUrl = '/dsh-cron/tasks/export' + (wantSanitized ? '?sanitize=true' : '');
+          const res = await fetch(exportUrl);
           const data = await res.json();
           if (!data.ok) {
             alert(T_KEY(t, 'transfer.exportFailed', { error: (data && data.error) || '' }));
@@ -1607,7 +1647,7 @@ window.__ModuleLoader__.load({
           const stamp = new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-');
           const anchor = document.createElement('a');
           anchor.href = url;
-          anchor.download = `dsh-cron-tasks-${stamp}.json`;
+          anchor.download = `dsh-cron-tasks-${stamp}${data.sanitized ? '-sanitized' : ''}.json`;
           document.body.appendChild(anchor);
           anchor.click();
           document.body.removeChild(anchor);
@@ -3145,9 +3185,9 @@ window.__ModuleLoader__.load({
               }, '✕')
             ),
             React.createElement('div', { style: { marginTop: '12px', display: 'flex', flexDirection: 'column', gap: '8px', fontSize: '13px' } },
-              React.createElement('div', null, React.createElement('strong', null, T_KEY(t, 'dryRun.status') + ': '), React.createElement('span', { style: { color: dryRunResult.ok ? 'var(--dsh-cron-success)' : 'var(--dsh-cron-danger)' } }, dryRunResult.ok ? (dryRunResult.result && dryRunResult.result.status || 'success') : 'failed')),
-              dryRunResult.result && dryRunResult.result.preflight && React.createElement('div', null, React.createElement('strong', null, T_KEY(t, 'dryRun.preflight') + ': '), React.createElement('span', null, dryRunResult.result.preflight.passed ? '✓ Passed' : '✗ Failed (' + (dryRunResult.result.preflight.reason || '') + ')')),
-              dryRunResult.result && React.createElement('div', null, React.createElement('strong', null, T_KEY(t, 'dryRun.duration') + ': '), React.createElement('span', null, (dryRunResult.result.durationMs || 0) + 'ms')),
+              React.createElement('div', null, React.createElement('strong', null, T_KEY(t, 'dryRun.status') + ': '), React.createElement('span', { style: { color: dryRunResult.ok ? 'var(--dsh-cron-success)' : 'var(--dsh-cron-danger)' } }, dryRunResult.ok ? ((dryRunResult.result && dryRunResult.result.status) || dryRunResult.status || 'success') : 'failed')),
+              ((dryRunResult.result && dryRunResult.result.preflight) || dryRunResult.preflight) && React.createElement('div', null, React.createElement('strong', null, T_KEY(t, 'dryRun.preflight') + ': '), React.createElement('span', null, (((dryRunResult.result && dryRunResult.result.preflight) || dryRunResult.preflight).passed) ? '✓ Passed' : '✗ Failed (' + ((((dryRunResult.result && dryRunResult.result.preflight) || dryRunResult.preflight).reason) || '') + ')')),
+              React.createElement('div', null, React.createElement('strong', null, T_KEY(t, 'dryRun.duration') + ': '), React.createElement('span', null, (((dryRunResult.result && dryRunResult.result.durationMs) !== undefined ? dryRunResult.result.durationMs : dryRunResult.durationMs) || 0) + 'ms')),
               React.createElement('div', { style: { marginTop: '6px' } }, React.createElement('strong', null, T_KEY(t, 'dryRun.output') + ':')),
               React.createElement('pre', {
                 style: {
@@ -3162,7 +3202,7 @@ window.__ModuleLoader__.load({
                   wordBreak: 'break-word',
                   color: 'var(--dsw-alias-label-primary)'
                 }
-              }, (dryRunResult.result && dryRunResult.result.output) || (dryRunResult.error) || '(no output)')
+              }, ((dryRunResult.result && dryRunResult.result.output) !== undefined ? dryRunResult.result.output : (dryRunResult.output !== undefined ? dryRunResult.output : ((dryRunResult.result && dryRunResult.result.error) || dryRunResult.error || '(no output)'))))
             ),
             React.createElement('div', { className: 'dsh-cron-modal-foot', style: { marginTop: '16px' } },
               React.createElement('button', {
@@ -3229,7 +3269,7 @@ window.__ModuleLoader__.load({
                 type: 'button',
                 className: 'dsh-cron-btn-secondary',
                 onClick: () => {
-                  const nextOffset = archiveOffset + 15;
+                  const nextOffset = archiveRuns.length;
                   if (archiveTask) openArchiveModal(archiveTask, nextOffset);
                 }
               }, T_KEY(t, 'archive.loadMore', { shown: archiveRuns.length, total: archiveTotal })) : React.createElement('div', null),

package/lib/index.js

@@ -185,14 +185,23 @@ export function apply(ctx, rawConfig) {
   // Heartbeat / dead man's snitch (#16): an optional periodic GET ping so an
   // external monitor can alert when this scheduler stops responding.
   let heartbeatTimer = null;
-  if (config && config.heartbeatUrl && Number(config.heartbeatIntervalSec) > 0) {
-    const intervalMs = Number(config.heartbeatIntervalSec) * 1000;
-    heartbeatTimer = setInterval(() => {
-      fetch(config.heartbeatUrl, { method: 'GET' }).catch((err) => {
-        logger.warn('[dsh-cron] heartbeat ping failed:', err.message);
-      });
-    }, intervalMs);
+  function updateHeartbeat(url, intervalSec) {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    const cleanUrl = String(url || '').trim();
+    const cleanSec = Number(intervalSec) || 0;
+    if (cleanUrl && cleanSec > 0) {
+      heartbeatTimer = setInterval(() => {
+        fetch(cleanUrl, { method: 'GET' }).catch((err) => {
+          logger.warn('[dsh-cron] heartbeat ping failed:', err.message);
+        });
+      }, cleanSec * 1000);
+      if (typeof heartbeatTimer.unref === 'function') heartbeatTimer.unref();
+    }
   }
+  updateHeartbeat(config && config.heartbeatUrl, config && config.heartbeatIntervalSec);
 
   ctx.effect(() => {
     return () => {
@@ -236,12 +245,29 @@ export function apply(ctx, rawConfig) {
           const { body, error } = await readBody(req, res);
           if (error) return;
           const payload = sanitizeSettingsPayload(body);
-          store.saveSettings(payload);
           const scopeErrors = await applySettingsToScope(settingsService, payload);
+          if (scopeErrors && scopeErrors.length > 0) {
+            sendJson(res, 500, {
+              ok: false,
+              error: `Settings scope update failed: ${scopeErrors.join('; ')}`,
+              scopeErrors,
+            });
+            return;
+          }
+          store.saveSettings(payload);
+          if (payload.maxConcurrent !== undefined && Number.isFinite(Number(payload.maxConcurrent))) {
+            scheduler.maxConcurrent = Number(payload.maxConcurrent);
+          }
+          if (payload.defaultTimezone !== undefined) {
+            scheduler.defaultTimezone = String(payload.defaultTimezone || '').trim();
+          }
+          if (payload.heartbeatUrl !== undefined || payload.heartbeatIntervalSec !== undefined) {
+            const current = store.getSettings();
+            updateHeartbeat(current.heartbeatUrl, current.heartbeatIntervalSec);
+          }
           sendJson(res, 200, {
             ok: true,
             settings: { ...store.getClientSettings(), version: pkgVersion },
-            scopeErrors: (scopeErrors && scopeErrors.length > 0) ? scopeErrors : undefined
           });
           return;
         }

package/lib/runtimes.js

@@ -46,14 +46,15 @@ function looksLikeScriptFile(token, extensions) {
 
 /** #5: resolve a Node.js invocation (inline code or a .js/.mjs/.cjs file). */
 export function buildNodeInvocation(task, cwd) {
+  const nodeExecutable = task.nodePath || process.execPath;
   const { path: filePath, args } = splitCommandLine(task.prompt);
   if (looksLikeScriptFile(filePath, ['.js', '.mjs', '.cjs'])) {
-    return { file: process.execPath, args: [filePath, ...args] };
+    return { file: nodeExecutable, args: [filePath, ...args] };
   }
   const code = String(task.prompt || '');
   const isEsm = /\bimport\s|\bexport\s/.test(code);
   const nodeArgs = isEsm ? ['--input-type=module', '-e', code] : ['-e', code];
-  return { file: task.nodePath || process.execPath, args: nodeArgs };
+  return { file: nodeExecutable, args: nodeArgs };
 }
 
 /** Find the Python interpreter, preferring a task virtualenv, then the workspace one. */

package/lib/scheduler-execution.js

@@ -261,6 +261,48 @@ export async function executeTask(scheduler, taskId, options = {}) {
   const task = scheduler.store.get(taskId);
   if (!task) return null;
 
+  // Dry-run path: read-only evaluation without mutating store, history, attempts, or triggering alerts (#229)
+  if (options.dryRun) {
+    const runs = (scheduler.store.history && scheduler.store.history.get(taskId)) || [];
+    const guard = checkTaskBudgetLimits(task, runs);
+    if (guard.exceeded) {
+      return {
+        ok: false,
+        dryRun: true,
+        status: 'error',
+        error: guard.reason,
+        preflightBlocked: true,
+      };
+    }
+    const preflight = await executePreflight(task);
+    if (!preflight.ok) {
+      return {
+        ok: false,
+        dryRun: true,
+        status: 'skipped',
+        error: `Preflight check skipped: ${preflight.reason}`,
+        preflightBlocked: true,
+      };
+    }
+    const start = Date.now();
+    const outcome = await scheduler.executeWithFallback(
+      task,
+      AbortSignal.timeout(Math.min((task.timeoutSeconds || 1800) * 1000, 30000)),
+      options
+    );
+    return {
+      ok: outcome.status !== 'error' && outcome.status !== 'timeout',
+      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 || '',
+    };
+  }
+
   // Pre-flight Burn Guard check (#181): prevent executing task if budget already breached
   const runs = (scheduler.store.history && scheduler.store.history.get(taskId)) || [];
   const guard = checkTaskBudgetLimits(task, runs);
@@ -277,22 +319,6 @@ export async function executeTask(scheduler, taskId, options = {}) {
     scheduler.store.set(task);
   }
 
-  if (options.dryRun) {
-    const start = Date.now();
-    const outcome = await scheduler.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 = scheduler.beginRun(task, taskId, options);
   if (currentRun === null) return null;
 
@@ -377,12 +403,23 @@ export async function applyModelAssists(task, runInfo, options) {
 /**
  * Deliver a finished run to every configured channel (#26).
  */
-export async function deliverNotifications(task, runInfo, { store, resolveSecrets, deliver }) {
+export async function deliverNotifications(task, runInfo, { store, resolveSecrets, deliver, secretTimeoutMs = 5000 }) {
   try {
     let settings = typeof store?.getSettings === 'function' ? store.getSettings() : {};
     if (resolveSecrets) {
       try {
-        settings = { ...settings, ...(await resolveSecrets(settings)) };
+        let timer;
+        const deadline = new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error(`credential resolution timed out after ${secretTimeoutMs}ms`)), secretTimeoutMs);
+          if (typeof timer.unref === 'function') timer.unref();
+        });
+        const resolved = await Promise.race([
+          Promise.resolve(resolveSecrets(settings)).finally(() => {
+            if (timer) clearTimeout(timer);
+          }),
+          deadline,
+        ]);
+        settings = { ...settings, ...(resolved || {}) };
       } catch (secErr) {
         logger.warn('[dsh-cron] credential resolution failed:', secErr.message);
       }

package/lib/settings.js

@@ -24,6 +24,7 @@ export const Config = z.object({
   maxConcurrent: z.number().default(2).description('Max parallel task runs (0 = unlimited, default 2)').volatile(),
   heartbeatUrl: z.string().default('').description('Dead man\'s snitch URL pinged on the heartbeat interval').volatile(),
   heartbeatIntervalSec: z.number().default(0).description('Heartbeat ping interval in seconds (0 = off)').volatile(),
+  llmActionsEnabled: z.boolean().default(false).description('Enable LLM actions execution').volatile(),
   // --- Delivery channels (#20-#23, #26, #28, #47) ---
   template: z.string().default('').description('Global notification template; placeholders: {title} {status} {output} {error} {duration} {schedule} {time} {tokens} {cost}').volatile(),
   channelTemplates: z.object({}).default({}).description('Per-channel template overrides keyed by channel id').volatile(),
@@ -77,6 +78,7 @@ export function unwrapConfig(cfg) {
 
 export const SETTINGS_SYNC_KEYS = [
   'botToken', 'botTokenRef', 'telegramWebhookSecret', 'chatId', 'notifyTelegram', 'onlyOnFailure', 'kanbanBaseUrl',
+  'defaultTimezone', 'maxConcurrent', 'heartbeatUrl', 'heartbeatIntervalSec', 'llmActionsEnabled',
   'template', 'channelTemplates', 'deliveryTimeoutMs', 'silentRuleModel', 'inspectorModel',
   'discordWebhookUrl', 'slackWebhookUrl',
   'ntfyUrl', 'ntfyTopic', 'ntfyTokenRef',

package/lib/store.js

@@ -38,14 +38,17 @@ export class TaskStore {
     this._lastBackupTime = 0;
     this._saveTimer = null;
     this._savePromise = Promise.resolve();
+    this._saveVersion = 0;
+    this._lastWrittenVersion = 0;
     this.init();
   }
 
   init() {
     const dir = path.dirname(this.filePath);
     if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+      fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     }
+    bestEffort('chmod-dir', () => fs.chmodSync(dir, 0o700));
     const bakPath = `${this.filePath}.bak`;
 
     const loadData = (raw) => {
@@ -84,22 +87,30 @@ export class TaskStore {
 
     if (fs.existsSync(this.filePath)) {
       try {
+        bestEffort('chmod-store', () => fs.chmodSync(this.filePath, 0o600));
         const raw = fs.readFileSync(this.filePath, 'utf-8');
         loadData(raw);
         if (!fs.existsSync(bakPath)) {
-          bestEffort('backup-initial', () => fs.copyFileSync(this.filePath, bakPath));
+          bestEffort('backup-initial', () => {
+            fs.copyFileSync(this.filePath, bakPath);
+            fs.chmodSync(bakPath, 0o600);
+          });
+        } else {
+          bestEffort('chmod-bak', () => fs.chmodSync(bakPath, 0o600));
         }
       } catch (err) {
         logger.error('[dsh-cron] store read error (corrupted file):', err.message);
         try {
           const corruptedPath = `${this.filePath}.corrupted.${Date.now()}`;
           fs.copyFileSync(this.filePath, corruptedPath);
+          bestEffort('chmod-corrupted', () => fs.chmodSync(corruptedPath, 0o600));
           logger.warn(`[dsh-cron] corrupted store backed up to ${corruptedPath}`);
         } catch (snapErr) {
           logger.error('[dsh-cron] failed to snapshot corrupted store:', snapErr.message);
         }
         if (fs.existsSync(bakPath)) {
           try {
+            bestEffort('chmod-bak', () => fs.chmodSync(bakPath, 0o600));
             const rawBak = fs.readFileSync(bakPath, 'utf-8');
             loadData(rawBak);
             logger.warn(`[dsh-cron] successfully recovered tasks store from ${bakPath}`);
@@ -110,9 +121,13 @@ export class TaskStore {
       }
     } else if (fs.existsSync(bakPath)) {
       try {
+        bestEffort('chmod-bak', () => fs.chmodSync(bakPath, 0o600));
         const rawBak = fs.readFileSync(bakPath, 'utf-8');
         loadData(rawBak);
-        bestEffort('restore-from-bak', () => fs.copyFileSync(bakPath, this.filePath));
+        bestEffort('restore-from-bak', () => {
+          fs.copyFileSync(bakPath, this.filePath);
+          fs.chmodSync(this.filePath, 0o600);
+        });
         logger.warn(`[dsh-cron] restored missing tasks store from ${bakPath}`);
       } catch (bakErr) {
         logger.error('[dsh-cron] failed to restore tasks store from .bak:', bakErr.message);
@@ -121,17 +136,16 @@ export class TaskStore {
   }
 
   /**
-   * Schedule a debounced save to avoid synchronous event loop blocking on high-frequency run completions.
+   * Schedule a debounced save using the asynchronous write queue to avoid
+   * blocking the event loop on large task stores (#244).
    */
   scheduleSave(delay = 50) {
     if (this._saveTimer) return;
     this._saveTimer = setTimeout(() => {
       this._saveTimer = null;
-      try {
-        this.save();
-      } catch (err) {
+      this.saveAsync().catch((err) => {
         logger.error('[dsh-cron] debounced save failed:', err.message);
-      }
+      });
     }, delay);
     if (typeof this._saveTimer.unref === 'function') {
       this._saveTimer.unref();
@@ -149,16 +163,72 @@ export class TaskStore {
     this.save();
   }
 
+  /**
+   * Asynchronously serialize and write tasks store to disk using fs.promises queue (#244).
+   * Safe mode 0600 on files and 0700 on dir (#222).
+   */
+  async saveAsync() {
+    const version = ++this._saveVersion;
+    const data = {
+      version: 1,
+      updatedAt: new Date().toISOString(),
+      tasks: Array.from(this.tasks.values()),
+      history: Object.fromEntries(this.history.entries()),
+      settings: this.settings || {},
+    };
+
+    const writeOp = async () => {
+      if (this._lastWrittenVersion >= version) {
+        return;
+      }
+      const dir = path.dirname(this.filePath);
+      await fs.promises.mkdir(dir, { recursive: true, mode: 0o700 });
+      bestEffort('chmod-dir', () => fs.chmodSync(dir, 0o700));
+
+      const rand = Math.random().toString(36).slice(2, 8);
+      const tmp = `${this.filePath}.tmp.${process.pid}_${Date.now()}_${rand}`;
+      const payload = JSON.stringify(data, null, 2);
+      await fs.promises.writeFile(tmp, payload, { encoding: 'utf-8', mode: 0o600 });
+      bestEffort('chmod-tmp', () => fs.chmodSync(tmp, 0o600));
+
+      if (this._lastWrittenVersion >= version) {
+        await fs.promises.unlink(tmp).catch(() => {});
+        return;
+      }
+
+      await fs.promises.rename(tmp, this.filePath);
+      bestEffort('chmod-store', () => fs.chmodSync(this.filePath, 0o600));
+      this._lastWrittenVersion = version;
+
+      const now = Date.now();
+      if (now - this._lastBackupTime > 60000) {
+        this._lastBackupTime = now;
+        try {
+          const bakPath = `${this.filePath}.bak`;
+          await fs.promises.copyFile(this.filePath, bakPath);
+          bestEffort('chmod-bak', () => fs.chmodSync(bakPath, 0o600));
+        } catch (bakErr) {
+          logger.warn('[dsh-cron] async backup copy failed:', bakErr.message);
+        }
+      }
+    };
+
+    this._savePromise = this._savePromise.then(writeOp, writeOp);
+    return this._savePromise;
+  }
+
   save() {
     if (this._saveTimer) {
       clearTimeout(this._saveTimer);
       this._saveTimer = null;
     }
+    const version = ++this._saveVersion;
     try {
       const dir = path.dirname(this.filePath);
       if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
       }
+      bestEffort('chmod-dir', () => fs.chmodSync(dir, 0o700));
       const data = {
         version: 1,
         updatedAt: new Date().toISOString(),
@@ -169,13 +239,21 @@ export class TaskStore {
       // Unique tmp file per save call with process PID and random token to eliminate file collision
       const rand = Math.random().toString(36).slice(2, 8);
       const tmp = `${this.filePath}.tmp.${process.pid}_${Date.now()}_${rand}`;
-      fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
+      fs.writeFileSync(tmp, JSON.stringify(data, null, 2), { encoding: 'utf-8', mode: 0o600 });
+      bestEffort('chmod-tmp', () => fs.chmodSync(tmp, 0o600));
       fs.renameSync(tmp, this.filePath);
+      bestEffort('chmod-store', () => fs.chmodSync(this.filePath, 0o600));
+      this._lastWrittenVersion = version;
+
       // Throttled backup (.bak): avoid expensive copyFileSync on every micro-save
       const now = Date.now();
       if (now - this._lastBackupTime > 60000) {
         this._lastBackupTime = now;
-        bestEffort('backup-on-save', () => fs.copyFileSync(this.filePath, `${this.filePath}.bak`));
+        bestEffort('backup-on-save', () => {
+          const bakPath = `${this.filePath}.bak`;
+          fs.copyFileSync(this.filePath, bakPath);
+          fs.chmodSync(bakPath, 0o600);
+        });
       }
     } catch (err) {
       logger.error('[dsh-cron] store save error:', err.message);
@@ -333,8 +411,12 @@ export class TaskStore {
       delivery: task.delivery !== undefined ? task.delivery : (prev.delivery || 'isolated'),
       provider: task.provider !== undefined ? task.provider : prev.provider,
       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),
+      notifyTelegram: task.notifyTelegram !== undefined
+        ? (task.notifyTelegram === null || task.notifyTelegram === 'inherit' ? undefined : Boolean(task.notifyTelegram))
+        : prev.notifyTelegram,
+      onlyOnFailure: task.onlyOnFailure !== undefined
+        ? (task.onlyOnFailure === null || task.onlyOnFailure === 'inherit' ? undefined : Boolean(task.onlyOnFailure))
+        : prev.onlyOnFailure,
       timeoutSeconds: task.timeoutSeconds !== undefined ? Number(task.timeoutSeconds) : (prev.timeoutSeconds || 1800),
       overlapPolicy: task.overlapPolicy !== undefined ? String(task.overlapPolicy) : (prev.overlapPolicy || 'skip'),
       kanbanMode: task.kanbanMode !== undefined ? String(task.kanbanMode) : (prev.kanbanMode || 'none'), // 'none' | 'on_failure' | 'always'
@@ -505,8 +587,10 @@ export class TaskStore {
       // Write atomically with tmp file using compact JSON (avoiding mega-lines and null, 2 serialization bloat)
       const rand = Math.random().toString(36).slice(2, 8);
       const tmp = `${archivePath}.tmp.${process.pid}_${Date.now()}_${rand}`;
-      fs.writeFileSync(tmp, JSON.stringify(archive), 'utf-8');
+      fs.writeFileSync(tmp, JSON.stringify(archive), { encoding: 'utf-8', mode: 0o600 });
+      bestEffort('chmod-tmp', () => fs.chmodSync(tmp, 0o600));
       fs.renameSync(tmp, archivePath);
+      bestEffort('chmod-archive', () => fs.chmodSync(archivePath, 0o600));
     } catch (archiveErr) {
       logger.error('[dsh-cron] history archive error:', archiveErr.message);
     }

package/lib/task-create.js

@@ -35,8 +35,8 @@ export function executeCreateTask(store, scheduler, args) {
     priority: Number(args.priority) || 5,
     selfHealingCommand: args.selfHealingCommand ? String(args.selfHealingCommand).trim() : '',
     autoDiagnose: Boolean(args.autoDiagnose),
-    notifyTelegram: Boolean(args.notifyTelegram),
-    onlyOnFailure: Boolean(args.onlyOnFailure),
+    notifyTelegram: args.notifyTelegram !== undefined ? Boolean(args.notifyTelegram) : undefined,
+    onlyOnFailure: args.onlyOnFailure !== undefined ? Boolean(args.onlyOnFailure) : undefined,
     timeoutSeconds: Number(args.timeoutSeconds) || 1800,
     overlapPolicy: args.overlapPolicy || 'skip',
     timezone: args.timezone ? String(args.timezone).trim() : '',

package/lib/task-transfer.js

@@ -162,16 +162,18 @@ export const IMPORT_STRATEGIES = ['add', 'replace', 'skip'];
  * `env` and headers can contain hand-typed secrets, so the caller must not
  * claim the file is secret-free.
  */
-export function buildTaskExport(tasks, { now = Date.now() } = {}) {
+export function buildTaskExport(tasks, { now = Date.now(), sanitize = false } = {}) {
   const list = Array.isArray(tasks) ? tasks : [];
   return {
     kind: TASK_EXPORT_KIND,
     version: TASK_EXPORT_VERSION,
     exportedAt: new Date(now).toISOString(),
+    sanitized: Boolean(sanitize),
     tasks: list.map((task) => {
       const out = {};
       for (const key of EXPORT_TASK_FIELDS) {
         if (task[key] === undefined || key === 'status') continue;
+        if (sanitize && EXPORT_SECRET_BEARING_FIELDS.includes(key)) continue;
         out[key] = Array.isArray(task[key]) ? [...task[key]] : task[key];
       }
       return out;
@@ -215,6 +217,26 @@ export function validateImportDocument(doc) {
     for (const key of DUPLICATE_TASK_FIELDS) {
       if (raw[key] !== undefined) clean[key] = Array.isArray(raw[key]) ? [...raw[key]] : raw[key];
     }
+    if (clean.env && typeof clean.env === 'object') {
+      const filteredEnv = {};
+      for (const [k, v] of Object.entries(clean.env)) {
+        if (typeof v === 'string' && (v.includes('••••') || v.trim() === '********')) {
+          continue; // Masked secret placeholder from UI/doc must never become literal secret (#240)
+        }
+        filteredEnv[k] = v;
+      }
+      clean.env = filteredEnv;
+    }
+    if (clean.httpHeaders && typeof clean.httpHeaders === 'object') {
+      const filteredHeaders = {};
+      for (const [k, v] of Object.entries(clean.httpHeaders)) {
+        if (typeof v === 'string' && (v.includes('••••') || v.trim() === '********')) {
+          continue;
+        }
+        filteredHeaders[k] = v;
+      }
+      clean.httpHeaders = filteredHeaders;
+    }
     if (id) clean.id = id;
     if (channels) clean.channels = channels;
     tasks.push(clean);

package/package.json

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