@goodandready/dsh-cron 0.2.50 → 0.2.52

package/lib/api.js

@@ -1,3 +1,5 @@
+import { approvalManager } from './approval.js';
+import { sanitizeValidators } from './validators.js';
 /**
  * REST surface of the plugin: the /dsh-cron/tasks and /dsh-cron/action route
  * families. Extracted from index.js and split into per-scope handlers so each
@@ -266,6 +268,7 @@ function buildTaskRecord(store, body, taskType, parsed) {
     maxRetries: body.maxRetries !== undefined ? Math.max(0, Number(body.maxRetries) || 0) : (current ? (Number(current.maxRetries) || 0) : 0),
     retryBackoffMs: body.retryBackoffMs !== undefined ? Math.max(1000, Number(body.retryBackoffMs) || 30000) : (current ? (Number(current.retryBackoffMs) || 30000) : 30000),
     permissionPreset: !EXTERNAL_RUNTIMES.includes(taskType) && ['default', 'read-only', 'workspace-write', 'full'].includes(body.permissionPreset) ? body.permissionPreset : (current && !EXTERNAL_RUNTIMES.includes(taskType) ? (current.permissionPreset || 'default') : 'default'),
+    validators: Array.isArray(body.validators) ? sanitizeValidators(body.validators) : (current ? current.validators : undefined),
     ...mergeExecutionFields(current, body, parsed),
   };
 }
@@ -341,6 +344,69 @@ async function handleTaskItem({ store, scheduler, req, res, url, id, action, api
 
 /** Task actions that are plain POSTs. Returns true when one matched. */
 async function handleItemPost({ store, scheduler, req, res, url, id, action }) {
+  if (action === 'retry-delivery') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBodyJson(req).catch(() => ({}));
+    const runId = body.runId || url.searchParams.get('runId');
+    const runs = store.history.get(id) || [];
+    const run = runId ? runs.find(r => r.id === runId) : runs[0];
+    if (!run) {
+      sendJson(res, 404, { ok: false, error: 'Run not found' });
+      return true;
+    }
+    const delivery = await scheduler.deliverNotifications(task, run);
+    run.delivery = delivery;
+    if (Array.isArray(run.stages)) {
+      const deliveryStage = run.stages.find(s => s.name === 'delivery');
+      if (deliveryStage) {
+        deliveryStage.status = delivery?.status || 'delivered';
+        deliveryStage.delivered = delivery?.delivered;
+        deliveryStage.failures = delivery?.failures;
+      }
+    }
+    store.scheduleSave();
+    sendJson(res, 200, { ok: true, delivery, run });
+    return true;
+  }
+  if (action === 'approve' || action === 'reject') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBodyJson(req).catch(() => ({}));
+    const proposalId = body.proposalId || url.searchParams.get('proposalId');
+    const proposal = proposalId
+      ? approvalManager.getProposal(proposalId)
+      : approvalManager.getPendingProposalForTask(id);
+
+    if (!proposal) {
+      sendJson(res, 404, { ok: false, error: 'No pending approval proposal found for this task' });
+      return true;
+    }
+
+    const decision = action === 'approve' ? 'approve' : 'reject';
+    const result = approvalManager.decide(proposal.id, decision, {
+      decidedBy: body.decidedBy || 'web-user',
+      reason: body.reason || '',
+    });
+
+    if (!result.ok) {
+      sendJson(res, 400, result);
+      return true;
+    }
+
+    if (decision === 'approve') {
+      scheduler.runTask(id, { approvedBy: body.decidedBy || 'web-user' }).catch(() => {});
+    }
+
+    sendJson(res, 200, { ok: true, proposal: result.proposal });
+    return true;
+  }
   if (action === 'run') {
     if (!store.get(id)) {
       sendJson(res, 404, NOT_FOUND);

package/lib/approval.js

@@ -0,0 +1,143 @@
+import { randomUUID } from 'node:crypto';
+import { logger } from './logger.js';
+
+/**
+ * Human-in-the-Loop Action Approval Engine (#318).
+ * Manages action approval proposals before execution, ensuring
+ * no dangerous side effects execute without authorized human confirmation.
+ */
+
+export const APPROVAL_STATES = {
+  PENDING: 'pending',
+  APPROVED: 'approved',
+  REJECTED: 'rejected',
+  EXPIRED: 'expired',
+  CANCELLED: 'cancelled',
+};
+
+/**
+ * Clean proposal object for storage and API responses.
+ */
+export function sanitizeProposal(proposal) {
+  if (!proposal || typeof proposal !== 'object') return null;
+  return {
+    id: String(proposal.id || randomUUID()),
+    taskId: String(proposal.taskId || ''),
+    runId: proposal.runId ? String(proposal.runId) : null,
+    actionType: String(proposal.actionType || 'execute'),
+    summary: String(proposal.summary || ''),
+    details: proposal.details && typeof proposal.details === 'object' ? proposal.details : {},
+    requestedAt: Number(proposal.requestedAt) || Date.now(),
+    expiresAt: Number(proposal.expiresAt) || (Date.now() + 3600000), // Default 1 hour
+    state: Object.values(APPROVAL_STATES).includes(proposal.state) ? proposal.state : APPROVAL_STATES.PENDING,
+    decidedAt: proposal.decidedAt ? Number(proposal.decidedAt) : null,
+    decidedBy: proposal.decidedBy ? String(proposal.decidedBy) : null,
+    reason: proposal.reason ? String(proposal.reason) : null,
+  };
+}
+
+/**
+ * In-memory / persistent registry for task proposals.
+ */
+export class ApprovalManager {
+  constructor() {
+    this.proposals = new Map();
+  }
+
+  /**
+   * Create a new pending approval proposal for a task.
+   */
+  createProposal(taskId, runId, { actionType = 'execute', summary = '', details = {}, timeoutMs = 3600000 } = {}) {
+    // If an existing pending proposal exists for this task, invalidate it as superseded
+    for (const [id, prop] of this.proposals.entries()) {
+      if (prop.taskId === taskId && prop.state === APPROVAL_STATES.PENDING) {
+        prop.state = APPROVAL_STATES.CANCELLED;
+        prop.decidedAt = Date.now();
+        prop.reason = 'Superseded by newer proposal';
+      }
+    }
+
+    const proposal = sanitizeProposal({
+      id: 'appr_' + randomUUID().replace(/-/g, '').slice(0, 12),
+      taskId,
+      runId,
+      actionType,
+      summary,
+      details,
+      requestedAt: Date.now(),
+      expiresAt: Date.now() + (Number(timeoutMs) > 0 ? Number(timeoutMs) : 3600000),
+      state: APPROVAL_STATES.PENDING,
+    });
+
+    this.proposals.set(proposal.id, proposal);
+    logger.info(`[dsh-cron] created approval proposal "${proposal.id}" for task "${taskId}": ${summary}`);
+    return proposal;
+  }
+
+  getProposal(proposalId) {
+    const prop = this.proposals.get(proposalId);
+    if (!prop) return null;
+    // Check expiration on read
+    if (prop.state === APPROVAL_STATES.PENDING && Date.now() > prop.expiresAt) {
+      prop.state = APPROVAL_STATES.EXPIRED;
+      prop.decidedAt = Date.now();
+      prop.reason = 'Approval expired';
+    }
+    return prop;
+  }
+
+  getPendingProposalForTask(taskId) {
+    for (const prop of this.proposals.values()) {
+      if (prop.taskId === taskId && prop.state === APPROVAL_STATES.PENDING) {
+        if (Date.now() > prop.expiresAt) {
+          prop.state = APPROVAL_STATES.EXPIRED;
+          prop.decidedAt = Date.now();
+          prop.reason = 'Approval expired';
+          continue;
+        }
+        return prop;
+      }
+    }
+    return null;
+  }
+
+  listProposals({ taskId = null, state = null } = {}) {
+    const list = [];
+    const now = Date.now();
+    for (const prop of this.proposals.values()) {
+      if (prop.state === APPROVAL_STATES.PENDING && now > prop.expiresAt) {
+        prop.state = APPROVAL_STATES.EXPIRED;
+        prop.decidedAt = now;
+        prop.reason = 'Approval expired';
+      }
+      if (taskId && prop.taskId !== taskId) continue;
+      if (state && prop.state !== state) continue;
+      list.push({ ...prop });
+    }
+    return list.sort((a, b) => b.requestedAt - a.requestedAt);
+  }
+
+  /**
+   * Decide on a proposal (approve or reject) with replay and double-click protection.
+   */
+  decide(proposalId, decision, { decidedBy = 'user', reason = '' } = {}) {
+    const prop = this.getProposal(proposalId);
+    if (!prop) {
+      return { ok: false, error: 'Proposal not found' };
+    }
+    if (prop.state !== APPROVAL_STATES.PENDING) {
+      return { ok: false, error: `Proposal already resolved with state: ${prop.state}`, proposal: prop };
+    }
+
+    const state = decision === 'approve' ? APPROVAL_STATES.APPROVED : APPROVAL_STATES.REJECTED;
+    prop.state = state;
+    prop.decidedAt = Date.now();
+    prop.decidedBy = decidedBy;
+    prop.reason = reason;
+
+    logger.info(`[dsh-cron] proposal "${proposalId}" ${state} by ${decidedBy}${reason ? ': ' + reason : ''}`);
+    return { ok: true, proposal: prop };
+  }
+}
+
+export const approvalManager = new ApprovalManager();

package/lib/channels.js

@@ -15,7 +15,7 @@ export const CHANNEL_IDS = ['telegram', 'kanban', 'discord', 'slack', 'ntfy', 'b
 
 // CHANNEL_LABELS removed (#155) — localized via lib/client.js
 
-export const isFailureStatus = (status) => status === 'error' || status === 'timeout' || status === 'missed';
+export const isFailureStatus = (status) => status === 'error' || status === 'timeout' || status === 'missed' || status === 'validation_failed' || status === 'validator_error';
 export const isFailed = (status) => isFailureStatus(status);
 
 /** The message text for a channel: task template -> channel template -> global template -> built-in defaults (#233). */
@@ -362,7 +362,9 @@ const CHANNEL_HANDLERS = {
   },
 
   async tts({ task, runInfo, settings, http, signal, timeoutMs }) {
-    const base = String(settings.ttsBaseUrl || 'http://127.0.0.1:3080').replace(/\/+$/, '');
+    const defaultPort = settings._webServerPort || settings.webServerPort || (settings.webServer && settings.webServer.port) || 3080;
+    const rawBase = String(settings.ttsBaseUrl || '').trim();
+    const base = (rawBase ? rawBase : `http://127.0.0.1:${defaultPort}`).replace(/\/+$/, '');
     const payload = { text: truncateText(messageTextFor('tts', task, runInfo, settings), 600) };
     const data = await postJson(http, `${base}/dsh-tts/speak`, { 'Content-Type': 'application/json' }, JSON.stringify(payload), 'tts', signal, timeoutMs);
     return { provider: data.provider || 'dsh-tts', tookMs: data.tookMs || null };