@goodandready/dsh-cron 0.2.6 → 0.2.8

package/lib/index.js

@@ -62,6 +62,9 @@ import { makeAsk } from './silent-rule.js';
 // a bare re-export creates no local binding and the plugin then fails to load
 // with "createCronApiHandler is not defined".
 import { createCronApiHandler } from './api.js';
+import { createMetricsHandler } from './metrics.js';
+import { applyConfigSync, isConfigOwned, configOwnedMessage } from './config-jobs.js';
+import { createExternalApiHandler, EXTERNAL_API_PREFIX } from './external-api.js';
 export { createCronApiHandler };
 
 export const name = '@goodandready/dsh-cron';
@@ -97,6 +100,16 @@ 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'),
+  // --- 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
+  // reject the whole profile config. Declared jobs are owned by the config:
+  // they are created or updated at startup, and removed when they disappear
+  // from the file. Tasks created in the UI, over the API or by an agent tool
+  // are never touched.
+  jobs: z.array(z.any()).default([]).description('Static jobs owned by the config; each entry needs id, title, schedule and (for agent types) prompt'),
+  // --- External REST API (#54, ADR-0001) ---
+  apiToken: z.string().role('secret').default('').description('Bearer token for the external /dsh-cron/api/* surface (empty = the surface answers 503)'),
 });
 
 
@@ -110,6 +123,7 @@ export const SETTINGS_SYNC_KEYS = [
   'pushplusUrl',
   'ttsBaseUrl',
   'giteaBaseUrl', 'giteaRepo', 'giteaTokenRef',
+  'apiToken',
 ];
 
 /**
@@ -327,6 +341,18 @@ export function apply(ctx, config) {
     }
   });
 
+  // #50: jobs declared in the profile config belong to the config. The sync
+  // runs before the scheduler starts and also when the section is gone: a
+  // config that dropped its jobs must still retire the tasks it used to own.
+  // 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 });
+    console.log('[dsh-cron] config jobs synced: ' + JSON.stringify(summary));
+  } catch (err) {
+    console.error('[dsh-cron] config job sync failed:', err.message);
+  }
+
   scheduler.start();
 
   // Heartbeat / dead man's snitch (#16): an optional periodic GET ping so an
@@ -366,6 +392,27 @@ export function apply(ctx, config) {
     handler: createCronApiHandler(store, scheduler, null)
   }), 'dsh-cron: /action/:id/:action');
 
+  // GET /dsh-cron/metrics (#53) — Prometheus text exposition
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-cron/metrics',
+    handler: createMetricsHandler({ store, scheduler })
+  }), 'dsh-cron: /metrics');
+
+  // External REST API under /dsh-cron/api/* (#54, ADR-0001): the only surface
+  // guarded by a bearer token, so CI and host automation can drive the
+  // scheduler without a browser session. The token is read per request, so a
+  // settings change applies without a restart.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: EXTERNAL_API_PREFIX,
+    handler: createExternalApiHandler({
+      store,
+      scheduler,
+      getToken: () => store.getSettings().apiToken || ''
+    })
+  }), 'dsh-cron: /api[...]');
+
   // GET /dsh-cron/models
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
@@ -595,6 +642,10 @@ export function apply(ctx, config) {
       render: (_args, val) => [{ type: 'text', text: val.message }]
     },
     execute: async (args) => {
+      // A config-owned task cannot be paused from here either: the next start
+      // would resume it, and the agent would have reported a change that never
+      // happened (#50 review finding).
+      if (isConfigOwned(store.get(args.id))) return { success: false, message: configOwnedMessage(args.id) };
       const task = scheduler.pauseTask(args.id);
       if (!task) return { success: false, message: 'Task not found' };
       return { success: true, message: `Task "${task.title}" paused` };
@@ -619,6 +670,7 @@ export function apply(ctx, config) {
       render: (_args, val) => [{ type: 'text', text: val.message }]
     },
     execute: async (args) => {
+      if (isConfigOwned(store.get(args.id))) return { success: false, message: configOwnedMessage(args.id) };
       const task = scheduler.resumeTask(args.id);
       if (!task) return { success: false, message: 'Task not found' };
       return { success: true, message: `Task "${task.title}" resumed (${task.scheduleText})` };
@@ -643,6 +695,9 @@ export function apply(ctx, config) {
       render: (_args, val) => [{ type: 'text', text: val.message }]
     },
     execute: async (args) => {
+      // Deleting a config-owned task would also drop its run history, and the
+      // task would come back at the next start without it.
+      if (isConfigOwned(store.get(args.id))) return { success: false, message: configOwnedMessage(args.id) };
       scheduler.pauseTask(args.id);
       const ok = store.delete(args.id);
       return { success: ok, message: ok ? 'Task deleted' : 'Task not found' };

package/lib/metrics.js

@@ -0,0 +1,97 @@
+/**
+ * Prometheus exposition of the scheduler (#53).
+ *
+ * The renderer is hand-rolled on purpose: the profile has no prom-client and
+ * adding a production dependency for a handful of counters is not justified.
+ * Only counts, statuses and durations are exported — never prompts, run output
+ * or task configuration, so the endpoint can be scraped without leaking work
+ * content.
+ */
+
+export const METRICS_CONTENT_TYPE = 'text/plain; version=0.0.4; charset=utf-8';
+
+/** Run statuses the scheduler can finish with. */
+export const RUN_STATUSES = ['success', 'error', 'timeout', 'skipped', 'missed'];
+
+const NL = String.fromCharCode(10);
+const BACKSLASH = String.fromCharCode(92);
+const QUOTE = String.fromCharCode(34);
+
+/** Escape a label value for the Prometheus text format. */
+export function escapeLabel(value) {
+  return String(value)
+    .split(BACKSLASH).join(BACKSLASH + BACKSLASH)
+    .split(QUOTE).join(BACKSLASH + QUOTE)
+    .split(NL).join(BACKSLASH + 'n');
+}
+
+function sample(name, labels, value) {
+  const rendered = Object.keys(labels)
+    .map((key) => key + '=' + QUOTE + escapeLabel(labels[key]) + QUOTE)
+    .join(',');
+  return name + (rendered ? '{' + rendered + '}' : '') + ' ' + value;
+}
+
+/**
+ * Render the current scheduler state as Prometheus text exposition.
+ * Pure function over plain data so it is testable without a store.
+ */
+export function renderMetrics({ tasks = [], stats = {}, runCounters = {} } = {}) {
+  const lines = [];
+  const byStatus = {};
+  for (const task of tasks) {
+    const status = task.status || 'unknown';
+    byStatus[status] = (byStatus[status] || 0) + 1;
+  }
+
+  lines.push('# HELP dsh_cron_tasks_total Scheduled tasks by status.');
+  // A gauge despite the name: this is a snapshot of how many tasks are in each
+  // state, not a monotonically growing total.
+  lines.push('# TYPE dsh_cron_tasks_total gauge');
+  for (const status of Object.keys(byStatus).sort()) {
+    lines.push(sample('dsh_cron_tasks_total', { status }, byStatus[status]));
+  }
+
+  lines.push('# HELP dsh_cron_task_last_duration_seconds Duration of the last finished run of a task.');
+  lines.push('# TYPE dsh_cron_task_last_duration_seconds gauge');
+  for (const task of tasks) {
+    // lastRunAt marks a finished run: a task that never ran still carries
+    // lastDurationMs = 0, and exporting that would show instant runs in
+    // monitoring.
+    if (!Number.isFinite(task.lastDurationMs) || !task.lastRunAt) continue;
+    lines.push(sample('dsh_cron_task_last_duration_seconds', { task: task.id }, task.lastDurationMs / 1000));
+  }
+
+  lines.push('# HELP dsh_cron_runs_total Finished runs since the plugin started, by status.');
+  lines.push('# TYPE dsh_cron_runs_total counter');
+  for (const status of RUN_STATUSES) {
+    lines.push(sample('dsh_cron_runs_total', { status }, Number(runCounters[status]) || 0));
+  }
+
+  lines.push('# HELP dsh_cron_run_records Run records currently kept in memory.');
+  lines.push('# TYPE dsh_cron_run_records gauge');
+  lines.push('dsh_cron_run_records ' + (Number(stats.totalRuns) || 0));
+
+  return lines.join(NL) + NL;
+}
+
+/**
+ * GET /dsh-cron/metrics — read-only. A scraper is a plain local client, so no
+ * cross-origin check applies, and nothing sensitive is exposed.
+ */
+export function createMetricsHandler({ store, scheduler }) {
+  return function handleMetrics(req, res) {
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      res.writeHead(405, { 'Content-Type': 'text/plain; charset=utf-8' });
+      res.end('Method not allowed' + NL);
+      return;
+    }
+    const body = renderMetrics({
+      tasks: store.list({ status: 'all' }),
+      stats: store.getAggregatedStats(),
+      runCounters: typeof scheduler.getRunCounters === 'function' ? scheduler.getRunCounters() : {},
+    });
+    res.writeHead(200, { 'Content-Type': METRICS_CONTENT_TYPE, 'Cache-Control': 'no-store' });
+    res.end(req.method === 'HEAD' ? undefined : body);
+  };
+}

package/lib/scheduler.js

@@ -36,82 +36,78 @@ export function describeCron(cronPattern) {
   return cronPattern;
 }
 
-export function parseScheduleExpression(input) {
-  const str = String(input || '').trim();
-  if (!str) throw new Error('Schedule expression must not be empty');
-
-  // 1. One-shot ISO 8601 timestamp or explicit "at: <ISO/datetime>"
+/** One-shot from an ISO timestamp or an explicit "at:" prefix, else null. */
+function parseAtExpression(str) {
   const atPrefixMatch = str.match(/^(?:at:\s*|at\s+)(.+)$/i);
   const candidateIso = atPrefixMatch ? atPrefixMatch[1].trim() : str;
   const parsedDate = new Date(candidateIso);
-  if (!isNaN(parsedDate.getTime()) && (candidateIso.includes('-') || candidateIso.includes('T') || atPrefixMatch)) {
-    const targetMs = parsedDate.getTime();
-    return {
-      cronPattern: null,
-      isOneShot: true,
-      targetTimestamp: targetMs,
-      humanText: `One-shot at ${parsedDate.toISOString()}`,
-      nextRun: targetMs
-    };
+  if (isNaN(parsedDate.getTime()) || !(candidateIso.includes('-') || candidateIso.includes('T') || atPrefixMatch)) {
+    return null;
   }
+  const targetMs = parsedDate.getTime();
+  return {
+    cronPattern: null,
+    isOneShot: true,
+    targetTimestamp: targetMs,
+    humanText: `One-shot at ${parsedDate.toISOString()}`,
+    nextRun: targetMs
+  };
+}
 
-  // 2. Relative one-shot: "in 20m", "in 2h", "in 30s", "in 1d", "через 15 минут"
-  //    Russian keywords are accepted input aliases, not display strings.
-  const inRelMatch = str.match(/^(?:in\s+|через\s+)(\d+)\s*(s|sec|seconds?|m|min|minutes?|h|hr|hours?|d|days?|мин|минут|часа?|часов)?$/i);
-  if (inRelMatch) {
-    const num = parseInt(inRelMatch[1], 10);
-    const unit = (inRelMatch[2] || 'm').toLowerCase();
-    let delayMs = num * 60 * 1000;
-    let unitText = `${num} min`;
-    if (unit.startsWith('s')) {
-      delayMs = num * 1000;
-      unitText = `${num} sec`;
-    } else if (unit.startsWith('h') || unit.startsWith('час')) {
-      delayMs = num * 3600 * 1000;
-      unitText = `${num} h`;
-    } else if (unit.startsWith('d')) {
-      delayMs = num * 86400 * 1000;
-      unitText = `${num} d`;
-    }
-    const targetMs = Date.now() + delayMs;
-    return {
-      cronPattern: null,
-      isOneShot: true,
-      targetTimestamp: targetMs,
-      humanText: `One-shot in ${unitText} (at ${new Date(targetMs).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })})`,
-      nextRun: targetMs
-    };
-  }
+/**
+ * Relative one-shot: "in 20m", "in 2h", "in 30s", "in 1d" and the accepted
+ * Russian input aliases ("через 15 минут").
+ */
+function parseRelativeOneShot(str) {
+  const match = str.match(/^(?:in\s+|через\s+)(\d+)\s*(s|sec|seconds?|m|min|minutes?|h|hr|hours?|d|days?|мин|минут|часа?|часов)?$/i);
+  if (!match) return null;
+  const num = parseInt(match[1], 10);
+  const unit = (match[2] || 'm').toLowerCase();
+  let delayMs = num * 60 * 1000;
+  let unitText = `${num} min`;
+  if (unit.startsWith('s')) {
+    delayMs = num * 1000;
+    unitText = `${num} sec`;
+  } else if (unit.startsWith('h') || unit.startsWith('час')) {
+    delayMs = num * 3600 * 1000;
+    unitText = `${num} h`;
+  } else if (unit.startsWith('d')) {
+    delayMs = num * 86400 * 1000;
+    unitText = `${num} d`;
+  }
+  const targetMs = Date.now() + delayMs;
+  return {
+    cronPattern: null,
+    isOneShot: true,
+    targetTimestamp: targetMs,
+    humanText: `One-shot in ${unitText} (at ${new Date(targetMs).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })})`,
+    nextRun: targetMs
+  };
+}
 
-  // 3. Repeating Interval: "every 5m", "every 2h", "every 1d"
-  const intervalMatch = str.match(/^every\s+(\d+)\s*(m|min|minute|minutes|h|hr|hour|hours|d|day|days)?$/i);
-  if (intervalMatch) {
-    const num = parseInt(intervalMatch[1], 10);
-    const unit = (intervalMatch[2] || 'm').toLowerCase();
-    if (unit.startsWith('m')) {
-      return {
-        cronPattern: `*/${num} * * * *`,
-        humanText: `Every ${num} minutes`,
-        isInterval: true,
-      };
-    }
-    if (unit.startsWith('h')) {
-      return {
-        cronPattern: `0 */${num} * * *`,
-        humanText: `Every ${num} hours`,
-        isInterval: true,
-      };
-    }
-    if (unit.startsWith('d')) {
-      return {
-        cronPattern: `0 0 */${num} * *`,
-        humanText: `Every ${num} days`,
-        isInterval: true,
-      };
-    }
+/** Repeating interval: "every 5m", "every 2h", "every 1d". */
+function parseIntervalExpression(str) {
+  const match = str.match(/^every\s+(\d+)\s*(m|min|minute|minutes|h|hr|hour|hours|d|day|days)?$/i);
+  if (!match) return null;
+  const num = parseInt(match[1], 10);
+  const unit = (match[2] || 'm').toLowerCase();
+  if (unit.startsWith('m')) {
+    return { cronPattern: `*/${num} * * * *`, humanText: `Every ${num} minutes`, isInterval: true };
   }
+  if (unit.startsWith('h')) {
+    return { cronPattern: `0 */${num} * * *`, humanText: `Every ${num} hours`, isInterval: true };
+  }
+  if (unit.startsWith('d')) {
+    return { cronPattern: `0 0 */${num} * *`, humanText: `Every ${num} days`, isInterval: true };
+  }
+  return null;
+}
 
-  // 4. Standard @-shorthands (#15)
+/**
+ * @-shorthands (#15) and the friendly aliases, including the Russian input
+ * aliases. Russian keywords are accepted input, not display strings.
+ */
+function parseAliasExpression(str) {
   const lower = str.toLowerCase();
   if (lower === '@hourly') return { cronPattern: '0 * * * *', humanText: 'Every hour' };
   if (lower === '@daily' || lower === '@midnight') return { cronPattern: '0 0 * * *', humanText: 'Every day at 00:00' };
@@ -120,10 +116,9 @@ export function parseScheduleExpression(input) {
   if (lower === '@yearly' || lower === '@annually') return { cronPattern: '0 0 1 1 *', humanText: 'Every year on Jan 1 at 00:00' };
   const everyAlias = str.match(/^@every\s+(\d+)\s*(sec|seconds?|m|min|minutes?|h|hr|hours?|d|days?)$/i);
   if (everyAlias) {
-    return parseScheduleExpression(`every ${everyAlias[1]} ${everyAlias[2]}`);
+    // "@every N unit" is another spelling of the interval branch.
+    return parseIntervalExpression(`every ${everyAlias[1]} ${everyAlias[2]}`);
   }
-
-  // 5. Friendly recurring aliases (English plus accepted Russian input aliases)
   if (lower === 'daily' || lower === 'каждый день') {
     return { cronPattern: '0 9 * * *', humanText: 'Every day at 09:00' };
   }
@@ -133,10 +128,16 @@ export function parseScheduleExpression(input) {
   if (lower === 'hourly' || lower === 'каждый час') {
     return { cronPattern: '0 * * * *', humanText: 'Every hour' };
   }
+  return null;
+}
 
-  // 5. Standard 5-field cron expression
+/** Validate a 5-field cron expression; the only branch that throws. */
+function parseCronExpression(str) {
   try {
-    const testJob = new Cron(str);
+    // #117: croner 10 made numeric-prefix steps (0/10, 30/30) a parse error,
+    // but stored schedules created under croner 9 use them. sloppyRanges
+    // restores the croner 9 range behaviour so existing tasks keep firing.
+    const testJob = new Cron(str, { sloppyRanges: true });
     const next = testJob.nextRun();
     return {
       cronPattern: str,
@@ -148,6 +149,22 @@ export function parseScheduleExpression(input) {
   }
 }
 
+/**
+ * Turn a typed schedule into a cron pattern or a one-shot target. The branch
+ * order is the contract: a timestamp, a relative one-shot, an interval and an
+ * alias are all more specific than a raw cron expression.
+ */
+export function parseScheduleExpression(input) {
+  const str = String(input || '').trim();
+  if (!str) throw new Error('Schedule expression must not be empty');
+
+  return parseAtExpression(str)
+    || parseRelativeOneShot(str)
+    || parseIntervalExpression(str)
+    || parseAliasExpression(str)
+    || parseCronExpression(str);
+}
+
 export class TaskScheduler {
   constructor(store, executeFn, options = {}) {
     this.store = store;
@@ -160,6 +177,7 @@ export class TaskScheduler {
     this.timers = new Map(); // taskId -> setTimeout handle (for one-shot tasks)
     this.retryTimers = new Map(); // taskId -> setTimeout handle (for #18 retries)
     this.running = new Map(); // taskId -> { controller, startedAt, queueCount }
+    this.runCounters = {}; // status -> finished runs since start (#53, /dsh-cron/metrics)
   }
 
   isRunning(taskId) {
@@ -194,6 +212,7 @@ export class TaskScheduler {
         const missedAt = task.nextRunAt;
         const policy = task.misfirePolicy || 'skip'; // #12: skip | runOnce | catchUpAll
         console.warn(`[dsh-cron] Task "${task.title}" (${task.id}) missed scheduled run at ${new Date(missedAt).toISOString()} (misfire: ${policy})`);
+        this.countRun('missed');
         this.store.recordRun(task.id, {
           at: missedAt,
           status: 'missed',
@@ -253,59 +272,66 @@ export class TaskScheduler {
     this.running.clear();
   }
 
-  scheduleTask(task) {
-    // Clear any existing job or timer for this task
-    if (this.jobs.has(task.id)) {
-      this.jobs.get(task.id).stop();
-      this.jobs.delete(task.id);
+  /** Drop an armed job or one-shot timer before re-scheduling a task. */
+  clearScheduled(taskId) {
+    if (this.jobs.has(taskId)) {
+      this.jobs.get(taskId).stop();
+      this.jobs.delete(taskId);
+    }
+    if (this.timers.has(taskId)) {
+      clearTimeout(this.timers.get(taskId));
+      this.timers.delete(taskId);
     }
-    if (this.timers.has(task.id)) {
-      clearTimeout(this.timers.get(task.id));
+  }
+
+  /** Arm a one-shot task; a target already in the past fires immediately. */
+  scheduleOneShot(task, parsed) {
+    task.oneShot = true;
+    task.nextRunAt = parsed.targetTimestamp;
+    this.store.set(task);
+
+    const delay = Math.max(0, parsed.targetTimestamp - Date.now());
+    const timer = setTimeout(() => {
       this.timers.delete(task.id);
+      this.runTask(task.id).catch((err) => {
+        console.error(`[dsh-cron] one-shot run of task ${task.id} failed:`, (err && err.message) || err);
+      });
+    }, delay);
+    this.timers.set(task.id, timer);
+  }
+
+  /** Arm a recurring cron job and persist the next run timestamp. */
+  scheduleCron(task, parsed) {
+    const timezone = task.timezone || this.defaultTimezone || undefined;
+    const job = new Cron(parsed.cronPattern, {
+      protect: true,
+      sloppyRanges: true, // #117: keep croner 9 range syntax working
+      catch: (err) => console.error(`[dsh-cron] scheduled run of "${task.title}" (${task.id}) failed:`, (err && err.message) || err),
+      ...(timezone ? { timezone } : {}),
+    }, async () => {
+      await this.runTask(task.id);
+    });
+
+    this.jobs.set(task.id, job);
+    const next = job.nextRun();
+    if (next) {
+      task.nextRunAt = next.getTime();
+      this.store.set(task);
     }
+  }
 
+  scheduleTask(task) {
+    this.clearScheduled(task.id);
     if (task.status !== 'active') return;
     this.clearRetryTimer(task.id);
 
     try {
       const parsed = parseScheduleExpression(task.schedule);
-      const timezone = task.timezone || this.defaultTimezone || undefined;
-
-      // Handle One-shot task
       if (parsed.isOneShot) {
-        task.oneShot = true;
-        const now = Date.now();
-        const delay = Math.max(0, parsed.targetTimestamp - now);
-        task.nextRunAt = parsed.targetTimestamp;
-        this.store.set(task);
-
-        // If target is in the past, or when delay triggers:
-        const timer = setTimeout(() => {
-          this.timers.delete(task.id);
-          this.runTask(task.id).catch((err) => {
-            console.error(`[dsh-cron] one-shot run of task ${task.id} failed:`, (err && err.message) || err);
-          });
-        }, delay);
-
-        this.timers.set(task.id, timer);
+        this.scheduleOneShot(task, parsed);
         return;
       }
-
-      // Handle Recurring Cron job
-      const job = new Cron(parsed.cronPattern, {
-        protect: true,
-        catch: (err) => console.error(`[dsh-cron] scheduled run of "${task.title}" (${task.id}) failed:`, (err && err.message) || err),
-        ...(timezone ? { timezone } : {}),
-      }, async () => {
-        await this.runTask(task.id);
-      });
-
-      this.jobs.set(task.id, job);
-      const next = job.nextRun();
-      if (next) {
-        task.nextRunAt = next.getTime();
-        this.store.set(task);
-      }
+      this.scheduleCron(task, parsed);
     } catch (err) {
       console.error(`[dsh-cron] failed to schedule task ${task.id}:`, err.message);
     }
@@ -351,8 +377,20 @@ export class TaskScheduler {
     return currentRun;
   }
 
+  /** Count a finished run for the metrics endpoint (#53). */
+  countRun(status) {
+    const key = status || 'unknown';
+    this.runCounters[key] = (this.runCounters[key] || 0) + 1;
+  }
+
+  /** Snapshot of the run counters; the caller must not mutate it. */
+  getRunCounters() {
+    return { ...this.runCounters };
+  }
+
   /** Record a run that never started, with the reason in the history entry. */
   recordSkipped(taskId, reason) {
+    this.countRun('skipped');
     this.store.recordRun(taskId, {
       at: Date.now(),
       status: 'skipped',
@@ -595,6 +633,7 @@ export class TaskScheduler {
    * cannot reject the cron callback.
    */
   finishRun(task, taskId, status, queuedCount) {
+    this.countRun(status);
     try {
       if (task.oneShot) {
         task.status = 'completed';

package/lib/store.js

@@ -8,8 +8,8 @@ import { getDshDefaultTelegramCredentials } from './telegram.js';
  * DSH_DATA_DIR wins when the harness sets it. Otherwise the profile home
  * (DSH_HOME) is authoritative: falling back to ~/.dsh would make an isolated
  * profile — a test contour, a second profile — write its tasks into another
- * home's data directory, which is how the MiniPC test cycle leaked a task into
- * the non-test profile.
+ * home's data directory, which is how an isolated test cycle once leaked a
+ * task into the wrong profile.
  */
 export function getDefaultStorePath() {
   const base = process.env.DSH_DATA_DIR
@@ -139,7 +139,7 @@ export class TaskStore {
    * fields (botTokenRef, ntfyTokenRef, …) take precedence over them.
    */
   static get MASKED_SETTING_KEYS() {
-    return ['botToken', 'discordWebhookUrl', 'slackWebhookUrl', 'barkKey'];
+    return ['botToken', 'discordWebhookUrl', 'slackWebhookUrl', 'barkKey', 'apiToken'];
   }
 
   saveSettings(newSettings = {}) {

package/lib/task-patch.js

@@ -12,6 +12,8 @@ import { parseScheduleExpression } from './scheduler.js';
 import { normalizeTaskType, CODE_EXECUTING_TYPES } from './runtimes.js';
 import { PATCHABLE_TASK_FIELDS, validateTaskType } from './task-transfer.js';
 import { pickPatchableFields } from './http-utils.js';
+import { unknownChannelIds } from './channels.js';
+import { isConfigOwned, configOwnedMessage } from './config-jobs.js';
 
 /** True when a patch changes a task into a type that executes code. */
 export function isCodeTypeSwitch(current, nextType) {
@@ -32,6 +34,15 @@ export function buildTaskPatch(current, body) {
     const typeError = validateTaskType(patch.type, { ...current, ...patch });
     if (typeError) return { ok: false, error: typeError };
   }
+  if (patch.channels !== undefined) {
+    // #121: a typo in a channel id used to be dropped silently, so the client
+    // got ok: true and a task that never notified anyone. The refusal lives
+    // here so the HTTP route and the tool behave identically.
+    const unknown = unknownChannelIds(patch.channels);
+    if (unknown.length) {
+      return { ok: false, error: 'Unknown channel ids: ' + unknown.join(', '), unknownChannels: unknown };
+    }
+  }
   if (patch.schedule !== undefined) {
     // An empty schedule would leave an armed task that can never fire.
     if (!String(patch.schedule).trim()) return { ok: false, error: 'Schedule cannot be empty' };
@@ -58,6 +69,12 @@ export function buildTaskPatch(current, body) {
 export function applyTaskPatch({ store, scheduler, id, body, allowCodeSwitch = false }) {
   const current = store.get(id);
   if (!current) return { ok: false, notFound: true, error: 'Task not found' };
+  // A task declared in the profile config (#50) is owned by that file: any
+  // change made here disappears at the next start, so the refusal lives with
+  // the patch logic and covers both the HTTP route and the agent tool.
+  if (isConfigOwned(current)) {
+    return { ok: false, configOwned: true, error: configOwnedMessage(id) };
+  }
   if (isCodeTypeSwitch(current, body && body.type) && allowCodeSwitch !== true) {
     return {
       ok: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Scheduled cron tasks, background automation and agent execution for DeepSeek Harness.",
   "type": "module",
   "main": "lib/index.js",
@@ -14,7 +14,8 @@
     "lib/",
     "cordis.patch.yml",
     "README.md",
-    "docs/",
+    "docs/README.ru.md",
+    "docs/README.zh.md",
     "LICENSE"
   ],
   "scripts": {
@@ -47,7 +48,7 @@
     }
   },
   "dependencies": {
-    "croner": "^9.1.0"
+    "croner": "^10.0.1"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",