@goodandready/dsh-cron 0.2.10 → 0.2.12

package/lib/api.js

@@ -6,7 +6,7 @@
  */
 
 import { randomUUID, createHash } from 'node:crypto';
-import { parseScheduleExpression } from './scheduler.js';
+import { parseScheduleExpression, previewSchedule } from './scheduler.js';
 import { normalizeTaskType, CODE_EXECUTING_TYPES } from './runtimes.js';
 import { CHANNEL_IDS, unknownChannelIds } from './channels.js';
 import { applyTaskPatch } from './task-patch.js';
@@ -60,6 +60,16 @@ export function createCronApiHandler(store, scheduler, collection) {
         return;
       }
 
+      if (scope === 'heartbeat' && id) {
+        handleHeartbeatPing({ store, req, res, taskId: id });
+        return;
+      }
+
+      if (scope === 'schedule' && id === 'preview') {
+        await handleSchedulePreview({ req, res, url });
+        return;
+      }
+
       if (!id) {
         await handleTaskCollection({ store, scheduler, collection, req, res, url, scope });
         return;
@@ -352,6 +362,16 @@ function applyImportPlan({ store, scheduler, plan }) {
 // ------------------------------------------------------------ single task
 
 async function handleTaskItem({ store, scheduler, req, res, url, id, action }) {
+  if ((req.method === 'GET' || req.method === 'POST') && action === 'heartbeat') {
+    handleHeartbeatPing({ store, req, res, taskId: id });
+    return;
+  }
+
+  if (req.method === 'POST' && action === 'dry-run') {
+    await handleDryRunTask({ store, scheduler, req, res, id });
+    return;
+  }
+
   if (req.method === 'GET' && action === 'archive') {
     const limit = parseInt(url.searchParams.get('limit') || '50', 10);
     const offset = parseInt(url.searchParams.get('offset') || '0', 10);
@@ -532,7 +552,15 @@ function mergeExecutionFields(current, body, parsed) {
  * tasks and the config-owned refusals are the same code, not a second copy.
  */
 export async function handleExternalTaskRequest({ store, scheduler, req, res, url }) {
-  const parts = url.pathname.split('/').filter(Boolean); // dsh-cron, api, tasks, :id?, :action?
+  const parts = url.pathname.split('/').filter(Boolean); // dsh-cron, api, [tasks|heartbeat|schedule], :id?, :action?
+  if (parts[2] === 'heartbeat' && parts[3]) {
+    handleHeartbeatPing({ store, req, res, taskId: parts[3] });
+    return;
+  }
+  if (parts[2] === 'schedule' && parts[3] === 'preview') {
+    await handleSchedulePreview({ req, res, url });
+    return;
+  }
   const id = parts[3];
   const action = parts[4];
 
@@ -681,3 +709,66 @@ export async function handleTelegramWebhook({ store, scheduler, req, res }) {
 
   sendJson(res, 200, { ok: true, verb, taskId });
 }
+
+export function handleHeartbeatPing({ store, req, res, taskId }) {
+  const task = store.get(taskId);
+  if (!task) {
+    sendJson(res, 404, { ok: false, error: 'Task not found' });
+    return;
+  }
+  const result = typeof store.recordHeartbeat === 'function' ? store.recordHeartbeat(taskId) : null;
+  if (!result) {
+    sendJson(res, 500, { ok: false, error: 'Could not record heartbeat' });
+    return;
+  }
+  sendJson(res, 200, result);
+}
+
+export async function handleSchedulePreview({ req, res, url }) {
+  let schedule = '';
+  let timezone = '';
+  let count = 5;
+
+  if (req.method === 'POST') {
+    const { body, error } = await readBody(req, res);
+    if (error) return;
+    schedule = body.schedule || '';
+    timezone = body.timezone || '';
+    count = body.count || 5;
+  } else if (req.method === 'GET') {
+    schedule = url.searchParams.get('schedule') || '';
+    timezone = url.searchParams.get('timezone') || '';
+    count = parseInt(url.searchParams.get('count') || '5', 10);
+  } else {
+    sendJson(res, 405, NOT_ALLOWED);
+    return;
+  }
+
+  if (!schedule) {
+    sendJson(res, 400, { ok: false, error: 'Field "schedule" is required' });
+    return;
+  }
+
+  try {
+    const preview = previewSchedule(schedule, { timezone, count });
+    sendJson(res, 200, { ok: true, ...preview });
+  } catch (err) {
+    sendJson(res, 400, { ok: false, error: err.message });
+  }
+}
+
+export async function handleDryRunTask({ store, scheduler, req, res, id }) {
+  if (rejectCrossOrigin(req, res)) return;
+  const task = store.get(id);
+  if (!task) {
+    sendJson(res, 404, { ok: false, error: 'Task not found' });
+    return;
+  }
+
+  try {
+    const outcome = await scheduler.runTask(id, { dryRun: true });
+    sendJson(res, 200, outcome || { ok: true, status: 'completed' });
+  } catch (err) {
+    sendJson(res, 500, { ok: false, error: err.message });
+  }
+}

package/lib/chat-start.js

@@ -40,13 +40,33 @@ export async function chatStartHandler(ctx, req, res, parseJsonBody, sendJson, r
     const model = body.model || defaultSel?.model;
 
     const cwd = process.cwd();
+    const presets = ctx.agentPresets || ctx.get?.('agentPresets');
+    let preset = null;
+    if (presets && typeof presets.resolve === 'function') {
+      try {
+        preset = await presets.resolve(body.agentPreset || 'standard');
+        if (preset && typeof presets.standingKeyFor === 'function') {
+          await presets.standingKeyFor(preset.id);
+        }
+      } catch (presetErr) {
+        ctx.logger?.warn?.(`[dsh-cron] could not resolve agentPreset: ${presetErr.message}`);
+      }
+    }
+
     const handle = await agents.create({
       sessionId: mintSessionId(),
       meta: {
         cwd,
-        agentPreset: 'standard',
+        agentPreset: preset ? preset.id : 'standard',
       },
       agentOptions: provider && model ? { provider, model } : undefined,
+      ...(preset ? {
+        setup: async (agentCtx) => {
+          if (typeof presets.mount === 'function') {
+            await presets.mount(agentCtx, preset.id);
+          }
+        }
+      } : {}),
     });
 
     const permissions = ctx.get?.('permissionPresets');