@goodandready/dsh-cron 0.3.25 → 0.3.26

package/lib/metrics.js

@@ -1,125 +1 @@
-import { rejectCrossOrigin } from './http-utils.js';
-/**
- * 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 = {}, scheduler } = {}) {
-  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));
-
-  if (scheduler && typeof scheduler.runningCount === 'function') {
-    lines.push('# HELP dsh_cron_concurrent_running Number of currently executing tasks.');
-    lines.push('# TYPE dsh_cron_concurrent_running gauge');
-    lines.push('dsh_cron_concurrent_running ' + (Number(scheduler.runningCount()) || 0));
-  }
-
-  lines.push('# HELP dsh_cron_task_tokens_total Cumulative tokens consumed by task.');
-  lines.push('# TYPE dsh_cron_task_tokens_total counter');
-  for (const task of tasks) {
-    if (Number(task.totalTokens) > 0) {
-      lines.push(sample('dsh_cron_task_tokens_total', { task: task.id }, task.totalTokens));
-    }
-  }
-
-  lines.push('# HELP dsh_cron_task_cost_usd_total Estimated cumulative LLM cost in USD.');
-  lines.push('# TYPE dsh_cron_task_cost_usd_total counter');
-  for (const task of tasks) {
-    if (Number(task.totalCostUsd) > 0) {
-      lines.push(sample('dsh_cron_task_cost_usd_total', { task: task.id }, task.totalCostUsd));
-    }
-  }
-
-  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 settings = store && typeof store.getSettings === 'function' ? store.getSettings() : {};
-    const apiToken = settings.apiToken;
-    if (rejectCrossOrigin(req, res, { apiToken })) return;
-
-    const body = renderMetrics({
-      tasks: store.list({ status: 'all' }),
-      stats: store.getAggregatedStats(),
-      runCounters: typeof scheduler.getRunCounters === 'function' ? scheduler.getRunCounters() : {},
-      scheduler,
-    });
-    res.writeHead(200, { 'Content-Type': METRICS_CONTENT_TYPE, 'Cache-Control': 'no-store' });
-    res.end(req.method === 'HEAD' ? undefined : body);
-  };
-}
+export * from './routes/metrics.js';

package/lib/routes/api-actions.js

@@ -0,0 +1,317 @@
+import { randomUUID } from 'node:crypto';
+import { captureGitDiff, discardGitChanges, applyGitDiff } from '../git-diff.js';
+import { applyDoctorFix, revertDoctorFix, diagnoseFailure } from '../doctor.js';
+import { rollbackPromptVersion } from '../prompt-evolver.js';
+import { approvalManager } from '../approval.js';
+import { MANAGED_BY_CONFIG } from '../config-jobs.js';
+import { sendJson, readBody, redactTaskSecrets } from '../http-utils.js';
+import { buildDuplicateTask } from '../task-transfer.js';
+import { refuseConfigOwned, NOT_FOUND } from './api-collection.js';
+
+export async function handleItemPost({ store, scheduler, req, res, url, id, action, subAction }) {
+  if (action === 'git-diff' && (subAction === 'discard' || subAction === 'revert')) {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const targetDir = task.cwd;
+    if (!targetDir) {
+      sendJson(res, 400, { ok: false, error: 'Task does not define a working directory (cwd)' });
+      return true;
+    }
+    const result = await discardGitChanges(targetDir);
+    sendJson(res, result.ok ? 200 : 500, result);
+    return true;
+  }
+
+  if (action === 'git-diff' && subAction === 'apply') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBody(req, res);
+    const bodyData = (body && body.body) || {};
+    let patch = bodyData.diff || bodyData.patch;
+    if (!patch) {
+      const runs = store.getHistory(id, 5);
+      const targetRun = runs.find((r) => r.gitDiff?.diff);
+      patch = targetRun?.gitDiff?.diff;
+    }
+    if (!patch) {
+      sendJson(res, 400, { ok: false, error: 'No diff patch provided or found in run history' });
+      return true;
+    }
+    const targetDir = task.cwd;
+    if (!targetDir) {
+      sendJson(res, 400, { ok: false, error: 'Task does not define a working directory (cwd)' });
+      return true;
+    }
+    const result = await applyGitDiff(targetDir, patch);
+    sendJson(res, result.ok ? 200 : 500, result);
+    return true;
+  }
+
+  if ((action === 'doctor' && subAction === 'apply') || action === 'doctor-apply') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBody(req, res);
+    const bodyData = (body && body.body) || {};
+    let fix = bodyData.fix || bodyData.doctorReport;
+    if (!fix) {
+      const runs = store.getHistory(id, 5);
+      const reportRun = runs.find((r) => r.doctorReport);
+      fix = reportRun?.doctorReport;
+    }
+    if (!fix || !fix.suggestedFix) {
+      sendJson(res, 400, { ok: false, error: 'No doctor fix found to apply' });
+      return true;
+    }
+    try {
+      const result = await applyDoctorFix(task, fix, { store, user: bodyData.user || 'operator' });
+      if (!result.ok) {
+        sendJson(res, 400, { ok: false, error: result.error });
+        return true;
+      }
+      sendJson(res, 200, {
+        ok: true,
+        taskId: id,
+        task: redactTaskSecrets(task),
+        revision: result.revision,
+      });
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: err.message });
+    }
+    return true;
+  }
+
+  if ((action === 'doctor' && subAction === 'revert') || action === 'doctor-revert') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBody(req, res);
+    const bodyData = (body && body.body) || {};
+    try {
+      const result = await revertDoctorFix(task, { store, user: bodyData.user || 'operator' });
+      if (!result.ok) {
+        sendJson(res, 400, { ok: false, error: result.error });
+        return true;
+      }
+      sendJson(res, 200, {
+        ok: true,
+        taskId: id,
+        task: redactTaskSecrets(task),
+        revertedCode: result.revertedCode,
+      });
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: err.message });
+    }
+    return true;
+  }
+
+  if ((action === 'doctor' && subAction === 'diagnose') || action === 'doctor-diagnose') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBody(req, res);
+    const bodyData = (body && body.body) || {};
+    const runId = bodyData.runId;
+    const runs = store.getHistory(id, 10);
+    const targetRun = runId ? runs.find((r) => r.id === runId) : runs[0];
+    if (!targetRun) {
+      sendJson(res, 404, { ok: false, error: 'No run history found to diagnose' });
+      return true;
+    }
+    try {
+      const doctorReport = await diagnoseFailure({
+        task,
+        runInfo: targetRun,
+        ask: scheduler?.askModel,
+      });
+      targetRun.doctorReport = doctorReport;
+      sendJson(res, 200, { ok: true, taskId: id, doctorReport });
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: err.message });
+    }
+    return true;
+  }
+  if (action === 'prompt-rollback') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBodyJson(req).catch(() => ({}));
+    const targetVersion = Number(body.version || url.searchParams.get('version'));
+    if (!targetVersion || targetVersion < 1) {
+      sendJson(res, 400, { ok: false, error: 'A valid target prompt version is required' });
+      return true;
+    }
+    try {
+      rollbackPromptVersion(task, targetVersion);
+      store.set(task);
+      sendJson(res, 200, {
+        ok: true,
+        task: redactTaskSecrets(task),
+        promptVersion: task.promptVersion,
+        promptHistory: task.promptHistory,
+      });
+    } catch (err) {
+      sendJson(res, 400, { ok: false, error: err.message });
+    }
+    return true;
+  }
+  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 === 'resolve-uncertain') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBody(req).then(b => JSON.parse(b || '{}')).catch(() => ({}));
+    const runId = body.runId || url.searchParams.get('runId');
+    if (!runId) {
+      sendJson(res, 400, { ok: false, error: 'runId is required' });
+      return true;
+    }
+    const result = store.durableJournal.resolveUncertain(id, runId, {
+      decision: body.decision || 'mark_failed',
+      note: body.note || '',
+      resolvedBy: body.resolvedBy || 'user',
+    });
+    if (!result.ok) {
+      sendJson(res, 400, result);
+      return true;
+    }
+    sendJson(res, 200, result);
+    return true;
+  }
+  if (action === 'run') {
+    if (!store.get(id)) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    await scheduler.triggerManualRun(id);
+    sendJson(res, 200, { ok: true, task: redactTaskSecrets(store.get(id)) });
+    return true;
+  }
+  if (action === 'duplicate') {
+    const source = store.get(id);
+    if (!source) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const copy = buildDuplicateTask(source, { id: randomUUID() });
+    try {
+      store.set(copy);
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: 'Failed to persist duplicate task: ' + err.message });
+      return true;
+    }
+    // A copy starts paused: it must never fire on its own before the user
+    // reviews the schedule (a duplicated one-shot may point at a past time).
+    scheduler.pauseTask(copy.id);
+    sendJson(res, 200, { ok: true, task: redactTaskSecrets(copy) });
+    return true;
+  }
+  if (action === 'pause' || action === 'resume') {
+    if (store.get(id) && store.get(id).managedBy === MANAGED_BY_CONFIG) {
+      refuseConfigOwned(res, id);
+      return true;
+    }
+    const task = action === 'pause' ? scheduler.pauseTask(id) : scheduler.resumeTask(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    sendJson(res, 200, { ok: true, task: redactTaskSecrets(task) });
+    return true;
+  }
+  if (action === 'toggle' || (!action && url.searchParams.get('action') === 'toggle')) {
+    const stored = store.get(id);
+    if (!stored) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    if (stored.managedBy === MANAGED_BY_CONFIG) {
+      refuseConfigOwned(res, id);
+      return true;
+    }
+    const task = scheduler.toggleTask(id);
+    sendJson(res, 200, { ok: true, task: redactTaskSecrets(task) });
+    return true;
+  }
+  return false;
+}
+
+