@goodandready/dsh-cron 0.3.24 → 0.3.26

package/lib/runtimes/runtimes.js

@@ -0,0 +1,198 @@
+import { bestEffort } from '../best-effort.js';
+/**
+ * Runtime invocation builders for non-LLM task types (#4, #5, #7, #8, #9, #38).
+ *
+ * Every builder is a pure function returning the process invocation
+ * ({ file, args, env }) or the HTTP request description, so the whole matrix
+ * is unit-testable without spawning anything.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const EXTERNAL_RUNTIMES = ['script', 'node', 'python', 'http', 'ssh', 'docker'];
+const AGENT_RUNTIMES = ['llm', 'skill', 'workflow'];
+export const TASK_TYPES = [...AGENT_RUNTIMES, ...EXTERNAL_RUNTIMES];
+
+/** Types that execute code and therefore need the HTTP confirm header. */
+export const CODE_EXECUTING_TYPES = ['script', 'node', 'python', 'ssh', 'docker'];
+
+export function normalizeTaskType(type) {
+  return TASK_TYPES.includes(type) ? type : 'llm';
+}
+
+/**
+ * Split a leading script path from trailing CLI arguments.
+ * Quoted segments are preserved as single arguments.
+ */
+export function splitCommandLine(text) {
+  const trimmed = String(text || '').trim();
+  if (!trimmed) return { path: '', args: [] };
+  const tokens = trimmed.match(/"[^"]*"|'[^']*'|\S+/g) || [];
+  const clean = tokens.map((t) => t.replace(/^["']|["']$/g, ''));
+  return { path: clean[0] || '', args: clean.slice(1) };
+}
+
+function looksLikeScriptFile(token, extensions) {
+  if (!token) return false;
+  const ext = path.extname(token).toLowerCase();
+  if (extensions.includes(ext)) return true;
+  try {
+    return fs.existsSync(token) && fs.statSync(token).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/** #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);
+  const flags = [];
+  if (Number(task.maxMemoryMb) > 0) {
+    flags.push(`--max-old-space-size=${Number(task.maxMemoryMb)}`);
+  }
+  if (looksLikeScriptFile(filePath, ['.js', '.mjs', '.cjs'])) {
+    return { file: nodeExecutable, args: [...flags, filePath, ...args] };
+  }
+  const code = String(task.prompt || '');
+  const isEsm = /\bimport\s|\bexport\s/.test(code);
+  const nodeArgs = isEsm ? [...flags, '--input-type=module', '-e', code] : [...flags, '-e', code];
+  return { file: nodeExecutable, args: nodeArgs };
+}
+
+/** Find the Python interpreter, preferring a task virtualenv, then the workspace one. */
+function detectPython(task, cwd) {
+  if (task.pythonPath) return task.pythonPath;
+  const candidates = [];
+  if (process.env.VIRTUAL_ENV) {
+    candidates.push(path.join(process.env.VIRTUAL_ENV, 'bin', 'python'));
+    candidates.push(path.join(process.env.VIRTUAL_ENV, 'Scripts', 'python.exe'));
+  }
+  const base = cwd || process.cwd();
+  candidates.push(path.join(base, '.venv', 'bin', 'python'));
+  candidates.push(path.join(base, '.venv', 'Scripts', 'python.exe'));
+  candidates.push(path.join(base, 'venv', 'bin', 'python'));
+  for (const candidate of candidates) {
+    const exists = bestEffort('check-python-candidate', () => fs.existsSync(candidate));
+    if (exists) return candidate;
+  }
+  return process.platform === 'win32' ? 'python' : 'python3';
+}
+
+/** #4: resolve a Python invocation (inline code or a .py file). */
+export function buildPythonInvocation(task, cwd) {
+  const interpreter = detectPython(task, cwd);
+  const { path: filePath, args } = splitCommandLine(task.prompt);
+  if (looksLikeScriptFile(filePath, ['.py'])) {
+    return { file: interpreter, args: [filePath, ...args] };
+  }
+  return { file: interpreter, args: ['-c', String(task.prompt || '')] };
+}
+
+/** #7: build the HTTP trigger request description. */
+export function buildHttpRequest(task) {
+  const raw = String(task.httpUrl || task.prompt || '').trim();
+  if (!raw) throw new Error('HTTP task requires a URL (httpUrl or prompt)');
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error(`Invalid HTTP URL: ${raw}`);
+  }
+  let headers = {};
+  if (task.httpHeaders) {
+    if (typeof task.httpHeaders === 'object') {
+      headers = { ...task.httpHeaders };
+    } else {
+      try {
+        headers = JSON.parse(String(task.httpHeaders));
+      } catch {
+        throw new Error('httpHeaders must be a JSON object');
+      }
+    }
+  }
+  const method = String(task.httpMethod || 'GET').toUpperCase();
+  const body = task.httpBody !== undefined && task.httpBody !== '' ? String(task.httpBody) : undefined;
+  return { url: url.toString(), method, headers, body };
+}
+
+/** #9: build a remote SSH invocation. */
+export function buildSshInvocation(task) {
+  const target = String(task.sshTarget || '').trim();
+  if (!target) throw new Error('SSH task requires sshTarget (user@host)');
+  const args = [];
+  if (task.sshPort) args.push('-p', String(Number(task.sshPort)));
+  if (task.sshKeyPath) args.push('-i', String(task.sshKeyPath));
+  args.push(target, String(task.prompt || 'true'));
+  return { file: 'ssh', args };
+}
+
+/** #8/#226: build Docker run invocation without leaking host process secrets into container. */
+export function buildDockerInvocation(task, explicitEnv) {
+  const image = String(task.dockerImage || '').trim();
+  if (!image) throw new Error('Docker task requires dockerImage');
+  const args = ['run', '--rm'];
+
+  // Issue #226: isolate container environment. If explicitEnv is passed directly
+  // (e.g. test or explicit invocation), use it; otherwise use task.env only.
+  let envMap = explicitEnv;
+  if (!envMap) {
+    envMap = {};
+    if (task && task.env && typeof task.env === 'object') {
+      for (const [k, v] of Object.entries(task.env)) {
+        if (v !== null && v !== undefined) envMap[k] = String(v);
+      }
+    }
+  }
+
+  for (const [key, value] of Object.entries(envMap)) {
+    if (key === 'PATH' || key === 'HOME') continue; // container owns those
+    if (value === null || value === undefined) continue;
+    args.push('-e', `${key}=${value}`);
+  }
+  if (Number(task.maxMemoryMb) > 0) args.push(`--memory=${Number(task.maxMemoryMb)}m`);
+  if (Number(task.cpus) > 0) args.push(`--cpus=${Number(task.cpus)}`);
+  if (task.cwd) args.push('-v', `${task.cwd}:/workspace`, '-w', '/workspace');
+  args.push(image, 'sh', '-lc', String(task.prompt || 'true'));
+  return { file: 'docker', args, env: envMap };
+}
+
+/** #38: merge task env vars over the base environment. */
+export function buildEnv(task, baseEnv) {
+  const env = { ...(baseEnv || process.env) };
+  if (task && task.env && typeof task.env === 'object') {
+    for (const [key, value] of Object.entries(task.env)) {
+      if (value === null || value === undefined) delete env[key];
+      else env[key] = String(value);
+    }
+  }
+  return env;
+}
+
+/**
+ * Dispatch an external (non-LLM) runtime to its invocation.
+ * Returns { file, args } plus an optional `http` descriptor for the fetch path.
+ */
+export function buildInvocation(task, cwd, baseEnv) {
+  const type = normalizeTaskType(task.type);
+  const env = buildEnv(task, baseEnv);
+  switch (type) {
+    case 'node':
+      return { type, env, ...buildNodeInvocation(task, cwd) };
+    case 'python':
+      return { type, env, ...buildPythonInvocation(task, cwd) };
+    case 'http':
+      return { type, env, http: buildHttpRequest(task) };
+    case 'ssh':
+      return { type, env, ...buildSshInvocation(task) };
+    case 'docker': {
+      // Issue #226: do not pass full host process.env into docker run
+      const dockerInvocation = buildDockerInvocation(task, task.env);
+      return { type, env: dockerInvocation.env, file: dockerInvocation.file, args: dockerInvocation.args };
+    }
+    case 'script':
+    default:
+      return { type: 'script', env, file: null, args: null, shellCommand: String(task.prompt || '') };
+  }
+}

package/lib/runtimes.js

@@ -1,198 +1 @@
-import { bestEffort } from './best-effort.js';
-/**
- * Runtime invocation builders for non-LLM task types (#4, #5, #7, #8, #9, #38).
- *
- * Every builder is a pure function returning the process invocation
- * ({ file, args, env }) or the HTTP request description, so the whole matrix
- * is unit-testable without spawning anything.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-
-export const EXTERNAL_RUNTIMES = ['script', 'node', 'python', 'http', 'ssh', 'docker'];
-const AGENT_RUNTIMES = ['llm', 'skill', 'workflow'];
-export const TASK_TYPES = [...AGENT_RUNTIMES, ...EXTERNAL_RUNTIMES];
-
-/** Types that execute code and therefore need the HTTP confirm header. */
-export const CODE_EXECUTING_TYPES = ['script', 'node', 'python', 'ssh', 'docker'];
-
-export function normalizeTaskType(type) {
-  return TASK_TYPES.includes(type) ? type : 'llm';
-}
-
-/**
- * Split a leading script path from trailing CLI arguments.
- * Quoted segments are preserved as single arguments.
- */
-export function splitCommandLine(text) {
-  const trimmed = String(text || '').trim();
-  if (!trimmed) return { path: '', args: [] };
-  const tokens = trimmed.match(/"[^"]*"|'[^']*'|\S+/g) || [];
-  const clean = tokens.map((t) => t.replace(/^["']|["']$/g, ''));
-  return { path: clean[0] || '', args: clean.slice(1) };
-}
-
-function looksLikeScriptFile(token, extensions) {
-  if (!token) return false;
-  const ext = path.extname(token).toLowerCase();
-  if (extensions.includes(ext)) return true;
-  try {
-    return fs.existsSync(token) && fs.statSync(token).isFile();
-  } catch {
-    return false;
-  }
-}
-
-/** #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);
-  const flags = [];
-  if (Number(task.maxMemoryMb) > 0) {
-    flags.push(`--max-old-space-size=${Number(task.maxMemoryMb)}`);
-  }
-  if (looksLikeScriptFile(filePath, ['.js', '.mjs', '.cjs'])) {
-    return { file: nodeExecutable, args: [...flags, filePath, ...args] };
-  }
-  const code = String(task.prompt || '');
-  const isEsm = /\bimport\s|\bexport\s/.test(code);
-  const nodeArgs = isEsm ? [...flags, '--input-type=module', '-e', code] : [...flags, '-e', code];
-  return { file: nodeExecutable, args: nodeArgs };
-}
-
-/** Find the Python interpreter, preferring a task virtualenv, then the workspace one. */
-function detectPython(task, cwd) {
-  if (task.pythonPath) return task.pythonPath;
-  const candidates = [];
-  if (process.env.VIRTUAL_ENV) {
-    candidates.push(path.join(process.env.VIRTUAL_ENV, 'bin', 'python'));
-    candidates.push(path.join(process.env.VIRTUAL_ENV, 'Scripts', 'python.exe'));
-  }
-  const base = cwd || process.cwd();
-  candidates.push(path.join(base, '.venv', 'bin', 'python'));
-  candidates.push(path.join(base, '.venv', 'Scripts', 'python.exe'));
-  candidates.push(path.join(base, 'venv', 'bin', 'python'));
-  for (const candidate of candidates) {
-    const exists = bestEffort('check-python-candidate', () => fs.existsSync(candidate));
-    if (exists) return candidate;
-  }
-  return process.platform === 'win32' ? 'python' : 'python3';
-}
-
-/** #4: resolve a Python invocation (inline code or a .py file). */
-export function buildPythonInvocation(task, cwd) {
-  const interpreter = detectPython(task, cwd);
-  const { path: filePath, args } = splitCommandLine(task.prompt);
-  if (looksLikeScriptFile(filePath, ['.py'])) {
-    return { file: interpreter, args: [filePath, ...args] };
-  }
-  return { file: interpreter, args: ['-c', String(task.prompt || '')] };
-}
-
-/** #7: build the HTTP trigger request description. */
-export function buildHttpRequest(task) {
-  const raw = String(task.httpUrl || task.prompt || '').trim();
-  if (!raw) throw new Error('HTTP task requires a URL (httpUrl or prompt)');
-  let url;
-  try {
-    url = new URL(raw);
-  } catch {
-    throw new Error(`Invalid HTTP URL: ${raw}`);
-  }
-  let headers = {};
-  if (task.httpHeaders) {
-    if (typeof task.httpHeaders === 'object') {
-      headers = { ...task.httpHeaders };
-    } else {
-      try {
-        headers = JSON.parse(String(task.httpHeaders));
-      } catch {
-        throw new Error('httpHeaders must be a JSON object');
-      }
-    }
-  }
-  const method = String(task.httpMethod || 'GET').toUpperCase();
-  const body = task.httpBody !== undefined && task.httpBody !== '' ? String(task.httpBody) : undefined;
-  return { url: url.toString(), method, headers, body };
-}
-
-/** #9: build a remote SSH invocation. */
-export function buildSshInvocation(task) {
-  const target = String(task.sshTarget || '').trim();
-  if (!target) throw new Error('SSH task requires sshTarget (user@host)');
-  const args = [];
-  if (task.sshPort) args.push('-p', String(Number(task.sshPort)));
-  if (task.sshKeyPath) args.push('-i', String(task.sshKeyPath));
-  args.push(target, String(task.prompt || 'true'));
-  return { file: 'ssh', args };
-}
-
-/** #8/#226: build Docker run invocation without leaking host process secrets into container. */
-export function buildDockerInvocation(task, explicitEnv) {
-  const image = String(task.dockerImage || '').trim();
-  if (!image) throw new Error('Docker task requires dockerImage');
-  const args = ['run', '--rm'];
-
-  // Issue #226: isolate container environment. If explicitEnv is passed directly
-  // (e.g. test or explicit invocation), use it; otherwise use task.env only.
-  let envMap = explicitEnv;
-  if (!envMap) {
-    envMap = {};
-    if (task && task.env && typeof task.env === 'object') {
-      for (const [k, v] of Object.entries(task.env)) {
-        if (v !== null && v !== undefined) envMap[k] = String(v);
-      }
-    }
-  }
-
-  for (const [key, value] of Object.entries(envMap)) {
-    if (key === 'PATH' || key === 'HOME') continue; // container owns those
-    if (value === null || value === undefined) continue;
-    args.push('-e', `${key}=${value}`);
-  }
-  if (Number(task.maxMemoryMb) > 0) args.push(`--memory=${Number(task.maxMemoryMb)}m`);
-  if (Number(task.cpus) > 0) args.push(`--cpus=${Number(task.cpus)}`);
-  if (task.cwd) args.push('-v', `${task.cwd}:/workspace`, '-w', '/workspace');
-  args.push(image, 'sh', '-lc', String(task.prompt || 'true'));
-  return { file: 'docker', args, env: envMap };
-}
-
-/** #38: merge task env vars over the base environment. */
-export function buildEnv(task, baseEnv) {
-  const env = { ...(baseEnv || process.env) };
-  if (task && task.env && typeof task.env === 'object') {
-    for (const [key, value] of Object.entries(task.env)) {
-      if (value === null || value === undefined) delete env[key];
-      else env[key] = String(value);
-    }
-  }
-  return env;
-}
-
-/**
- * Dispatch an external (non-LLM) runtime to its invocation.
- * Returns { file, args } plus an optional `http` descriptor for the fetch path.
- */
-export function buildInvocation(task, cwd, baseEnv) {
-  const type = normalizeTaskType(task.type);
-  const env = buildEnv(task, baseEnv);
-  switch (type) {
-    case 'node':
-      return { type, env, ...buildNodeInvocation(task, cwd) };
-    case 'python':
-      return { type, env, ...buildPythonInvocation(task, cwd) };
-    case 'http':
-      return { type, env, http: buildHttpRequest(task) };
-    case 'ssh':
-      return { type, env, ...buildSshInvocation(task) };
-    case 'docker': {
-      // Issue #226: do not pass full host process.env into docker run
-      const dockerInvocation = buildDockerInvocation(task, task.env);
-      return { type, env: dockerInvocation.env, file: dockerInvocation.file, args: dockerInvocation.args };
-    }
-    case 'script':
-    default:
-      return { type: 'script', env, file: null, args: null, shellCommand: String(task.prompt || '') };
-  }
-}
+export * from './runtimes/runtimes.js';

package/lib/scheduler/index.js

@@ -0,0 +1,6 @@
+export * from './scheduler.js';
+export * from './scheduler-execution.js';
+export * from './scheduler-completion.js';
+export * from './scheduler-lifecycle.js';
+export * from './scheduler-assists.js';
+export * from './scheduler-preflight.js';

package/lib/scheduler/scheduler-assists.js

@@ -0,0 +1,142 @@
+import { inspectFailure } from '../failure-inspector.js';
+import { applySilentRule } from '../silent-rule.js';
+import { logger } from '../logger.js';
+import { shouldAutoHeal, applyDoctorFix } from '../doctor.js';
+
+/**
+ * Ask the model to diagnose a failed run (#43). Never throws.
+ */
+export async function inspectFailureRun(task, runInfo, { askModel, readSettingsFn, inspectTimeoutMs }) {
+  if (typeof askModel !== 'function') return { inspected: false, error: 'no model is available' };
+  const settings = readSettingsFn ? readSettingsFn() : {};
+  try {
+    return await inspectFailure({
+      task,
+      runInfo,
+      ask: askModel,
+      preferredModel: String(settings.inspectorModel || ''),
+      timeoutMs: inspectTimeoutMs || 25000,
+    });
+  } catch (err) {
+    return { inspected: false, error: err.message };
+  }
+}
+
+/**
+ * Ask the silent rule whether this run should be delivered (#44).
+ * Never throws: any problem means "deliver".
+ */
+export async function applySilentRuleToRun(task, runInfo, { askModel, readSettingsFn, silentRuleTimeoutMs }) {
+  if (typeof askModel !== 'function') return { skipped: false, reason: '' };
+  const preferredModel = String((readSettingsFn ? readSettingsFn() : {}).silentRuleModel || '');
+  try {
+    return await applySilentRule({
+      task,
+      runInfo,
+      ask: askModel,
+      preferredModel,
+      timeoutMs: silentRuleTimeoutMs || 20000,
+    });
+  } catch (err) {
+    return { skipped: false, reason: '', verdictError: err.message };
+  }
+}
+
+/**
+ * Run the model-assisted steps for a finished run.
+ */
+export async function applyModelAssists(task, runInfo, options = {}) {
+  const inspection = await inspectFailureRun(task, runInfo, options);
+  if (inspection.inspected) {
+    runInfo.diagnosis = inspection.diagnosis;
+    runInfo.suggestion = inspection.suggestion;
+    runInfo.confidence = inspection.confidence;
+    runInfo.doctorReport = inspection.doctorReport || {
+      category: inspection.category || 'runtime_error',
+      cause: inspection.diagnosis,
+      suggestedFix: inspection.suggestion,
+      confidence: inspection.confidence,
+      diff: inspection.diff || '',
+      timestamp: Date.now(),
+      applied: false,
+      autoHealed: false,
+    };
+    logger.info(`[dsh-cron] task "${task.title}" failure diagnosed (${inspection.confidence}): ${inspection.diagnosis}`);
+
+    // Safe Auto-Heal Check (#353)
+    if (shouldAutoHeal(task, runInfo.doctorReport)) {
+      try {
+        const healResult = await applyDoctorFix(task, runInfo.doctorReport, {
+          store: options.store,
+          user: 'scheduler:auto-heal',
+          isAutoHeal: true,
+        });
+        if (healResult.ok) {
+          logger.info(`[dsh-cron] task "${task.title}" auto-healed successfully with doctor fix!`);
+          runInfo.autoHealed = true;
+          if (runInfo.doctorReport) runInfo.doctorReport.autoHealed = true;
+        }
+      } catch (autoHealErr) {
+        logger.warn(`[dsh-cron] failed to auto-heal task "${task.title}":`, autoHealErr.message);
+      }
+    }
+  } else if (inspection.error && (task.inspectOnFailure || task.autoDiagnose || task.autoHeal)) {
+    logger.warn(`[dsh-cron] failure inspection for "${task.title}" not applied: ${inspection.error}`);
+  }
+
+  const silent = await applySilentRuleToRun(task, runInfo, options);
+  if (silent.skipped) {
+    runInfo.silentSkip = true;
+    runInfo.silentReason = silent.reason;
+    logger.info(`[dsh-cron] task "${task.title}" stayed silent by rule: ${silent.reason || 'no reason given'}`);
+  } else if (silent.verdictError) {
+    logger.warn(`[dsh-cron] silent rule for "${task.title}" not applied: ${silent.verdictError}`);
+  }
+  return silent;
+}
+
+/**
+ * Deliver a finished run to every configured channel (#26).
+ */
+export async function deliverNotifications(task, runInfo, { store, resolveSecrets, deliver, secretTimeoutMs = 5000 }) {
+  try {
+    let settings = typeof store?.getSettings === 'function' ? store.getSettings() : {};
+    if (resolveSecrets) {
+      try {
+        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);
+      }
+    }
+    if (typeof deliver !== 'function') return { status: 'skipped', delivered: [], failures: [] };
+    const result = await deliver(task, runInfo, settings);
+    if (result && Array.isArray(result.delivered) && result.delivered.length) {
+      logger.info(`[dsh-cron] delivered "${task.title}" to: ${result.delivered.map((d) => d.channel).join(', ')}`);
+    }
+    if (result && Array.isArray(result.failures) && result.failures.length) {
+      logger.warn(`[dsh-cron] delivery failures for "${task.title}": ${result.failures.map((f) => `${f.channel}: ${f.error}`).join('; ')}`);
+    }
+    const delivered = Array.isArray(result?.delivered) ? result.delivered : [];
+    const failures = Array.isArray(result?.failures) ? result.failures : [];
+    let status = 'skipped';
+    if (delivered.length > 0 && failures.length === 0) status = 'delivered';
+    else if (delivered.length > 0 && failures.length > 0) status = 'partial';
+    else if (delivered.length === 0 && failures.length > 0) status = 'failed';
+    return { status, delivered, failures };
+  } catch (notifyErr) {
+    logger.error('[dsh-cron] notification error:', notifyErr.message);
+    return { status: 'failed', delivered: [], failures: [{ channel: 'all', error: notifyErr.message }] };
+  }
+}
+