@goodandready/dsh-cron 0.3.0 → 0.3.2

package/lib/dag.js

@@ -0,0 +1,330 @@
+/**
+ * Directed Acyclic Graph (DAG) Engine for Chained Tasks (#328, #334)
+ * Provides cycle detection, topological sorting, dependency resolution,
+ * and graph visualization modeling for multi-step task workflows.
+ */
+
+/**
+ * Normalizes dependency specifications into an array of string task IDs.
+ * Accepts arrays, comma/space separated strings, or single task IDs.
+ *
+ * @param {string|string[]|undefined|null} deps
+ * @returns {string[]} Deduplicated array of valid task IDs
+ */
+export function sanitizeDependsOn(deps) {
+  if (!deps) return [];
+  let rawList = [];
+  if (Array.isArray(deps)) {
+    rawList = deps;
+  } else if (typeof deps === 'string') {
+    rawList = deps.split(/[,;\s]+/);
+  }
+  const result = [];
+  const seen = new Set();
+  for (const item of rawList) {
+    if (typeof item !== 'string') continue;
+    const trimmed = item.trim();
+    if (trimmed && !seen.has(trimmed)) {
+      seen.add(trimmed);
+      result.push(trimmed);
+    }
+  }
+  return result;
+}
+
+/**
+ * Validates join policy string.
+ *
+ * @param {string|undefined} policy
+ * @returns {'all_success'|'any_success'}
+ */
+export function sanitizeJoinPolicy(policy) {
+  if (policy === 'any_success') return 'any_success';
+  return 'all_success';
+}
+
+/**
+ * Parses and returns a list of target task IDs for chaining (onSuccess / onFailure).
+ * Supports single ID, comma-separated IDs, or arrays of IDs.
+ *
+ * @param {string|string[]|undefined|null} target
+ * @returns {string[]}
+ */
+export function parseChainTargets(target) {
+  if (!target) return [];
+  if (Array.isArray(target)) {
+    return target.map((t) => String(t || '').trim()).filter(Boolean);
+  }
+  if (typeof target === 'string') {
+    return target.split(/[,;\s]+/).map((t) => t.trim()).filter(Boolean);
+  }
+  return [];
+}
+
+/**
+ * Validates that adding or updating a task does not introduce cyclic dependencies.
+ * Analyzes both `dependsOn` relationships and `onSuccess` chain links.
+ *
+ * @param {Array<Object>|Map<string, Object>|Object} allTasks All current tasks
+ * @param {Object} [pendingTask] Task being created or updated
+ * @returns {{ ok: boolean, error?: string, cycle?: string[] }}
+ */
+export function validateDAG(allTasks, pendingTask = null) {
+  // Build task dictionary
+  const taskMap = new Map();
+  if (Array.isArray(allTasks)) {
+    for (const t of allTasks) {
+      if (t && t.id) taskMap.set(t.id, t);
+    }
+  } else if (allTasks instanceof Map) {
+    for (const [k, v] of allTasks.entries()) {
+      if (v && v.id) taskMap.set(v.id, v);
+    }
+  } else if (allTasks && typeof allTasks === 'object') {
+    for (const k of Object.keys(allTasks)) {
+      const t = allTasks[k];
+      if (t && t.id) taskMap.set(t.id, t);
+    }
+  }
+
+  // Merge pending task if provided
+  if (pendingTask && pendingTask.id) {
+    taskMap.set(pendingTask.id, { ...(taskMap.get(pendingTask.id) || {}), ...pendingTask });
+  }
+
+  // Self-dependency check
+  for (const [id, task] of taskMap.entries()) {
+    const deps = sanitizeDependsOn(task.dependsOn);
+    if (deps.includes(id)) {
+      return { ok: false, error: `Task "${task.title || id}" cannot depend on itself`, cycle: [id, id] };
+    }
+    const chainTargets = parseChainTargets(task.onSuccess);
+    if (chainTargets.includes(id)) {
+      return { ok: false, error: `Task "${task.title || id}" cannot trigger itself as next step`, cycle: [id, id] };
+    }
+  }
+
+  // Construct adjacency list: Edge from U to V means U must complete before V runs.
+  // Sources of edges:
+  // 1) dependsOn: If V depends on U, then U -> V
+  // 2) onSuccess: If U has onSuccess V, then U -> V
+  const adj = new Map();
+  for (const id of taskMap.keys()) {
+    adj.set(id, new Set());
+  }
+
+  for (const [id, task] of taskMap.entries()) {
+    // 1) dependsOn (deps -> id)
+    const deps = sanitizeDependsOn(task.dependsOn);
+    for (const depId of deps) {
+      if (!adj.has(depId)) adj.set(depId, new Set());
+      adj.get(depId).add(id);
+    }
+
+    // 2) onSuccess (id -> target)
+    const targets = parseChainTargets(task.onSuccess);
+    for (const targetId of targets) {
+      if (!adj.has(id)) adj.set(id, new Set());
+      adj.get(id).add(targetId);
+    }
+  }
+
+  // DFS Cycle Detection (3 colors: 0=unvisited, 1=visiting, 2=visited)
+  const state = new Map(); // id -> 0 | 1 | 2
+  const path = [];
+
+  for (const node of adj.keys()) {
+    state.set(node, 0);
+  }
+
+  function dfs(u) {
+    state.set(u, 1);
+    path.push(u);
+
+    const neighbors = adj.get(u) || new Set();
+    for (const v of neighbors) {
+      const vState = state.get(v) || 0;
+      if (vState === 1) {
+        // Cycle detected
+        const cycleStartIndex = path.indexOf(v);
+        const cyclePath = path.slice(cycleStartIndex).concat(v);
+        return { ok: false, error: `Cyclic dependency detected: ${cyclePath.join(' -> ')}`, cycle: cyclePath };
+      }
+      if (vState === 0) {
+        const res = dfs(v);
+        if (!res.ok) return res;
+      }
+    }
+
+    path.pop();
+    state.set(u, 2);
+    return { ok: true };
+  }
+
+  for (const node of adj.keys()) {
+    if ((state.get(node) || 0) === 0) {
+      const res = dfs(node);
+      if (!res.ok) return res;
+    }
+  }
+
+  return { ok: true };
+}
+
+/**
+ * Returns topological sort of task IDs or throws error if cycle exists.
+ *
+ * @param {Array<Object>|Map<string, Object>} tasks
+ * @returns {string[]} Ordered task IDs
+ */
+export function topologicalSort(tasks) {
+  const check = validateDAG(tasks);
+  if (!check.ok) {
+    throw new Error(check.error || 'Cyclic dependency in task DAG');
+  }
+
+  const taskMap = new Map();
+  if (Array.isArray(tasks)) {
+    for (const t of tasks) if (t?.id) taskMap.set(t.id, t);
+  } else if (tasks instanceof Map) {
+    for (const [k, v] of tasks.entries()) if (v?.id) taskMap.set(v.id, v);
+  }
+
+  // In-degree calculation
+  const inDegree = new Map();
+  const adj = new Map();
+  for (const id of taskMap.keys()) {
+    inDegree.set(id, 0);
+    adj.set(id, new Set());
+  }
+
+  for (const [id, task] of taskMap.entries()) {
+    const deps = sanitizeDependsOn(task.dependsOn);
+    for (const depId of deps) {
+      if (taskMap.has(depId)) {
+        adj.get(depId).add(id);
+        inDegree.set(id, (inDegree.get(id) || 0) + 1);
+      }
+    }
+    const targets = parseChainTargets(task.onSuccess);
+    for (const targetId of targets) {
+      if (taskMap.has(targetId)) {
+        adj.get(id).add(targetId);
+        inDegree.set(targetId, (inDegree.get(targetId) || 0) + 1);
+      }
+    }
+  }
+
+  const queue = [];
+  for (const [id, deg] of inDegree.entries()) {
+    if (deg === 0) queue.push(id);
+  }
+
+  const order = [];
+  while (queue.length > 0) {
+    const u = queue.shift();
+    order.push(u);
+    for (const v of adj.get(u) || []) {
+      const newDeg = (inDegree.get(v) || 0) - 1;
+      inDegree.set(v, newDeg);
+      if (newDeg === 0) queue.push(v);
+    }
+  }
+
+  return order;
+}
+
+/**
+ * Builds a visual graph model (nodes and edges) for UI rendering (#334).
+ *
+ * @param {Array<Object>} tasks All relevant tasks
+ * @param {Array<Object>} [snapshots] Checkpoints for the chain run
+ * @param {string} [focusTaskId] Task ID to center or highlight
+ * @returns {{ nodes: Array<Object>, edges: Array<Object>, hasFailure: boolean }}
+ */
+export function buildTaskGraphModel(tasks = [], snapshots = [], focusTaskId = null) {
+  const taskMap = new Map();
+  for (const t of tasks) {
+    if (t?.id) taskMap.set(t.id, t);
+  }
+
+  const snapshotMap = new Map();
+  for (const s of snapshots) {
+    if (s?.stepTaskId) snapshotMap.set(s.stepTaskId, s);
+  }
+
+  const nodes = [];
+  const edges = [];
+  let hasFailure = false;
+
+  for (const [id, task] of taskMap.entries()) {
+    const snap = snapshotMap.get(id);
+    let nodeStatus = 'pending';
+    let durationMs = 0;
+    let outputSnippet = '';
+    let retryCount = 0;
+
+    if (snap) {
+      nodeStatus = snap.status === 'completed' || snap.status === 'success' ? 'success' : 'failed';
+      durationMs = snap.durationMs || 0;
+      retryCount = snap.retryCount || 0;
+      if (snap.output) {
+        outputSnippet = String(snap.output).slice(0, 200);
+      }
+      if (nodeStatus === 'failed') {
+        hasFailure = true;
+      }
+    } else if (task.status === 'running') {
+      nodeStatus = 'running';
+    }
+
+    nodes.push({
+      id,
+      title: task.title || id,
+      type: task.type || 'prompt',
+      status: nodeStatus,
+      durationMs,
+      retryCount,
+      outputSnippet,
+      isFocus: Boolean(focusTaskId && id === focusTaskId),
+      isRetryable: nodeStatus === 'failed',
+      dependsOn: sanitizeDependsOn(task.dependsOn),
+      joinPolicy: sanitizeJoinPolicy(task.joinPolicy),
+    });
+
+    // Edges from dependsOn
+    const deps = sanitizeDependsOn(task.dependsOn);
+    for (const depId of deps) {
+      edges.push({
+        from: depId,
+        to: id,
+        type: 'dependsOn',
+        label: task.joinPolicy === 'any_success' ? 'join:any' : 'join:all',
+      });
+    }
+
+    // Edges from onSuccess
+    const targets = parseChainTargets(task.onSuccess);
+    for (const targetId of targets) {
+      edges.push({
+        from: id,
+        to: targetId,
+        type: 'onSuccess',
+        label: 'onSuccess',
+      });
+    }
+
+    // Edges from onFailure
+    const failTargets = parseChainTargets(task.onFailure);
+    for (const failId of failTargets) {
+      edges.push({
+        from: id,
+        to: failId,
+        type: 'onFailure',
+        label: 'onFailure',
+      });
+    }
+  }
+
+  return { nodes, edges, hasFailure };
+}

package/lib/prompt-interpolation.js

@@ -25,7 +25,12 @@ export function buildPromptContext(task = {}, options = {}) {
   const prevDuration = formatDuration(options.prevDurationMs);
   const prevCost = options.prevCostUsd != null ? `$${Number(options.prevCostUsd || 0).toFixed(4)}` : '';
 
-  return {
+  const filePath = options.filePath != null ? String(options.filePath) : '';
+  const fileName = options.fileName != null ? String(options.fileName) : '';
+  const fileSize = options.fileSize != null ? String(options.fileSize) : '';
+  const fileEvent = options.fileEvent != null ? String(options.fileEvent) : '';
+
+  const ctx = {
     // Chaining context
     'prev.output': prevOutput,
     'prev_output': prevOutput,
@@ -39,6 +44,20 @@ export function buildPromptContext(task = {}, options = {}) {
     'prev.cost': prevCost,
     'prev_cost': prevCost,
 
+    // File watcher context (#327)
+    'filePath': filePath,
+    'file.path': filePath,
+    'file_path': filePath,
+    'fileName': fileName,
+    'file.name': fileName,
+    'file_name': fileName,
+    'fileSize': fileSize,
+    'file.size': fileSize,
+    'file_size': fileSize,
+    'fileEvent': fileEvent,
+    'file.event': fileEvent,
+    'file_event': fileEvent,
+
     // Time context
     'date': formatDate(now),
     'time': formatTime(now),
@@ -53,17 +72,41 @@ export function buildPromptContext(task = {}, options = {}) {
     'task.title': task.title || '',
     'task_title': task.title || '',
   };
+
+  // DAG / Fan-In predecessor outputs (#328)
+  if (options.prevOutputs && typeof options.prevOutputs === 'object') {
+    for (const [k, v] of Object.entries(options.prevOutputs)) {
+      const valStr = v != null ? String(v) : '';
+      ctx[`prevOutputs.${k}`] = valStr;
+      ctx[`outputs.${k}`] = valStr;
+      ctx[`step.${k}.output`] = valStr;
+      ctx[`prevOutputs['${k}']`] = valStr;
+      ctx[`prevOutputs["${k}"]`] = valStr;
+    }
+  }
+
+  return ctx;
 }
 
 /**
  * Replace {{var}} or {var} placeholders with values from context.
- * Supports dot notation like {{prev.output}}. Unknown variables are left untouched.
+ * Supports dot notation like {{prev.output}} and bracket notation like {{prevOutputs['step1']}}.
  */
 export function interpolateTaskPrompt(text, context = {}) {
   if (typeof text !== 'string') return text;
   if (!text) return '';
 
-  return text.replace(/\{\{([a-zA-Z0-9_.]+)\}\}/g, (match, varName) => {
+  // 1. Bracket notation: {{prevOutputs['step1']}} or {prevOutputs['step1']} or with double quotes
+  let result = text.replace(/\{\{?prevOutputs\[['"]([^'"]+)['"]\]\}?\}/g, (match, stepId) => {
+    const key = `prevOutputs.${stepId}`;
+    if (Object.prototype.hasOwnProperty.call(context, key)) {
+      return context[key];
+    }
+    return match;
+  });
+
+  // 2. Standard {{var}} and {var}
+  result = result.replace(/\{\{([a-zA-Z0-9_.]+)\}\}/g, (match, varName) => {
     if (Object.prototype.hasOwnProperty.call(context, varName)) {
       const val = context[varName];
       return val == null ? '' : String(val);
@@ -76,6 +119,8 @@ export function interpolateTaskPrompt(text, context = {}) {
     }
     return match;
   });
+
+  return result;
 }
 
 /**

package/lib/routes.js

@@ -10,6 +10,7 @@ import { recipesByCategory } from './recipes.js';
 import { sendTelegramMessage, createTelegramTaskKeyboard } from './telegram.js';
 import { createKanbanCard } from './integrations.js';
 import { sanitizeSettingsPayload, applySettingsToScope } from './settings.js';
+import { buildTaskGraphModel } from './dag.js';
 
 export function registerRoutes(ctx, { store, scheduler, recommendations }) {
   // handler per route family; registered WITHOUT the trailing slash (#96)
@@ -220,6 +221,27 @@ export function registerRoutes(ctx, { store, scheduler, recommendations }) {
 export async function handleChainRoutes(store, scheduler, req, res) {
   if (req.method === 'POST' && rejectCrossOrigin(req, res)) return;
   const url = new URL(req.url, 'http://localhost');
+
+  // GET /dsh-cron/chains/:chainRunId (#334)
+  const getMatch = url.pathname.match(/^\/dsh-cron\/chains\/([^\/]+)$/);
+  if (getMatch && req.method === 'GET') {
+    const chainRunId = getMatch[1];
+    const snapshots = store.chainCheckpointManager ? store.chainCheckpointManager.getChainSnapshots(chainRunId) : [];
+    const relevantTasks = [];
+    const stepIds = new Set(snapshots.map((s) => s.stepTaskId));
+    if (store.tasks) {
+      for (const t of Object.values(store.tasks)) {
+        if (t && (stepIds.has(t.id) || t.onSuccess || t.onFailure || t.dependsOn)) {
+          relevantTasks.push(t);
+        }
+      }
+    }
+    const graph = buildTaskGraphModel(relevantTasks, snapshots);
+    sendJson(res, 200, { ok: true, chainRunId, snapshots, graph });
+    return;
+  }
+
+  // POST /dsh-cron/chains/:chainRunId/retry-from/:stepTaskId (#319, #328)
   const m = url.pathname.match(/^\/dsh-cron\/chains\/([^\/]+)\/retry-from\/([^\/]+)$/);
   if (!m) {
     sendJson(res, 404, { ok: false, error: 'Route not found' });

package/lib/runner.js

@@ -1,6 +1,7 @@
 import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 import { estimateTokenCost } from './integrations.js';
+import { resolveDynamicCredentialsInText, resolveDynamicCredentialsInObject } from './secrets.js';
 import {
   EXTERNAL_RUNTIMES,
   normalizeTaskType,
@@ -144,7 +145,104 @@ export class SessionRunner {
   async _run(task, signal, options = {}) {
     logger.info(`[dsh-cron] executing task "${task.title}" (${task.id})`);
 
-    // 1. Non-LLM runtimes: shell, Node.js, Python, HTTP, SSH, Docker (#4 #5 #7 #8 #9)
+    // Dynamic credentials resolution in-memory (#335)
+    let effectiveTask = task;
+    const resolvedSecrets = [];
+    const settings = (this.store && typeof this.store.getSettings === 'function')
+      ? this.store.getSettings()
+      : {};
+
+    if (settings.enableDynamicCredentials) {
+      effectiveTask = { ...task };
+      if (typeof effectiveTask.prompt === 'string') {
+        const res = await resolveDynamicCredentialsInText(effectiveTask.prompt, this.ctx);
+        effectiveTask.prompt = res.text;
+        resolvedSecrets.push(...res.resolvedSecrets);
+      }
+      if (typeof effectiveTask.script === 'string') {
+        const res = await resolveDynamicCredentialsInText(effectiveTask.script, this.ctx);
+        effectiveTask.script = res.text;
+        resolvedSecrets.push(...res.resolvedSecrets);
+      }
+      if (typeof effectiveTask.command === 'string') {
+        const res = await resolveDynamicCredentialsInText(effectiveTask.command, this.ctx);
+        effectiveTask.command = res.text;
+        resolvedSecrets.push(...res.resolvedSecrets);
+      }
+      if (typeof effectiveTask.httpUrl === 'string') {
+        const res = await resolveDynamicCredentialsInText(effectiveTask.httpUrl, this.ctx);
+        effectiveTask.httpUrl = res.text;
+        resolvedSecrets.push(...res.resolvedSecrets);
+      }
+      if (typeof effectiveTask.httpBody === 'string') {
+        const res = await resolveDynamicCredentialsInText(effectiveTask.httpBody, this.ctx);
+        effectiveTask.httpBody = res.text;
+        resolvedSecrets.push(...res.resolvedSecrets);
+      }
+      if (effectiveTask.httpHeaders) {
+        const res = await resolveDynamicCredentialsInObject(effectiveTask.httpHeaders, this.ctx);
+        effectiveTask.httpHeaders = res.data;
+        resolvedSecrets.push(...res.resolvedSecrets);
+      }
+      if (effectiveTask.env) {
+        const res = await resolveDynamicCredentialsInObject(effectiveTask.env, this.ctx);
+        effectiveTask.env = res.data;
+        resolvedSecrets.push(...res.resolvedSecrets);
+      }
+    }
+
+    const maskSecrets = (result) => {
+      if (!result || typeof result !== 'object') return result;
+      if (resolvedSecrets.length > 0 && typeof result.output === 'string') {
+        let out = result.output;
+        for (const secret of resolvedSecrets) {
+          if (secret && String(secret).length >= 4 && out.includes(secret)) {
+            out = out.replaceAll(secret, '[REDACTED_CREDENTIAL]');
+          }
+        }
+        result.output = out;
+      }
+      return result;
+    };
+
+    const runInternal = async () => {
+      // 1. Non-LLM runtimes: shell, Node.js, Python, HTTP, SSH, Docker (#4 #5 #7 #8 #9)
+      const runtime = normalizeTaskType(effectiveTask.type);
+      if (EXTERNAL_RUNTIMES.includes(runtime) || effectiveTask.mode === 'no-llm') {
+        return this._runExternal(effectiveTask, runtime === 'llm' ? 'script' : runtime, signal, options);
+      }
+
+      // 2. Agent session, when the harness exposes one
+      if (this.ctx && this.ctx.agents && typeof this.ctx.agents.create === 'function') {
+        return this._runAgentSession(effectiveTask, runtime, signal, options);
+      }
+
+      // 3. Legacy session service
+      if (this.ctx && this.ctx.session && typeof this.ctx.session.create === 'function') {
+        return this._runLegacySession(effectiveTask, options);
+      }
+
+      // 4. Nothing to run through: report the prompt as triggered
+      return this._runBare(effectiveTask, options);
+    };
+
+    try {
+      const outcome = await runInternal();
+      return maskSecrets(outcome);
+    } catch (err) {
+      if (resolvedSecrets.length > 0 && err && err.message) {
+        for (const secret of resolvedSecrets) {
+          if (secret && String(secret).length >= 4 && err.message.includes(secret)) {
+            err.message = err.message.replaceAll(secret, '[REDACTED_CREDENTIAL]');
+          }
+        }
+      }
+      throw err;
+    }
+  }
+
+  // Legacy dispatch replaced above; original runner helpers remain unchanged below:
+  async _runOriginalDispatch(task, signal, options = {}) {
     const runtime = normalizeTaskType(task.type);
     if (EXTERNAL_RUNTIMES.includes(runtime) || task.mode === 'no-llm') {
       return this._runExternal(task, runtime === 'llm' ? 'script' : runtime, signal, options);