@goodandready/dsh-cron 0.2.19 → 0.2.20

package/lib/api-helpers.js

@@ -0,0 +1,68 @@
+import { previewSchedule } from './scheduler.js';
+import { sendJson, readBody, rejectCrossOrigin } from './http-utils.js';
+
+const NOT_ALLOWED = { ok: false, error: 'Method not allowed' };
+
+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/api-import-export.js

@@ -0,0 +1,145 @@
+import { randomUUID } from 'node:crypto';
+import {
+  buildTaskExport,
+  validateImportDocument,
+  planImport,
+  hasCodeExecutingTask,
+  IMPORT_STRATEGIES,
+} from './task-transfer.js';
+import { unknownChannelIds } from './channels.js';
+import {
+  sendJson,
+  readBody,
+  SCRIPT_CONFIRM_HEADER,
+} from './http-utils.js';
+import { MANAGED_BY_CONFIG } from './config-jobs.js';
+
+export function handleTaskExport({ store, res }) {
+  const doc = buildTaskExport(store.list({ status: 'all' }));
+  sendJson(res, 200, { ok: true, document: doc, count: doc.tasks.length });
+}
+
+export async function handleTaskImport({ store, scheduler, req, res }) {
+  const { body, error } = await readBody(req, res);
+  if (error) return;
+  const strategy = IMPORT_STRATEGIES.includes(body && body.strategy) ? body.strategy : 'skip';
+  const checked = validateImportDocument(body && body.document);
+  if (!checked.ok) {
+    sendJson(res, 400, { ok: false, error: checked.error });
+    return;
+  }
+  // The import file is external input: importing code-executing tasks needs
+  // the same explicit confirmation that creating one over HTTP needs,
+  // otherwise a hand-edited file would bypass that gate (#86).
+  if (hasCodeExecutingTask(checked.tasks) && req.headers[SCRIPT_CONFIRM_HEADER] !== 'script') {
+    sendJson(res, 403, {
+      ok: false,
+      error: `Importing code-executing tasks over HTTP requires the ${SCRIPT_CONFIRM_HEADER}: script header`,
+    });
+    return;
+  }
+  // #121: an imported file may name a channel this build no longer has. The
+  // import stays tolerant by design (#42), but the loss is reported instead of
+  // being invisible.
+  const rawTasks = Array.isArray(body.document && body.document.tasks) ? body.document.tasks : [];
+  const droppedChannels = [];
+  for (const item of rawTasks) {
+    for (const id of unknownChannelIds(item.channels)) {
+      if (!droppedChannels.includes(id)) droppedChannels.push(id);
+    }
+  }
+  if (droppedChannels.length) {
+    console.warn('[dsh-cron] import: unknown channel ids were dropped: ' + droppedChannels.join(', '));
+  }
+  const existingIds = store.list({ status: 'all' }).map((x) => x.id);
+  const plan = planImport(checked.tasks, existingIds, strategy);
+  // Replacing a task the config owns would be undone at the next start, and
+  // the id could then hold two different tasks (#50).
+  const configConflicts = plan.replace
+    .map((item) => item.id)
+    .filter((taskId) => {
+      const stored = store.get(taskId);
+      return stored && stored.managedBy === MANAGED_BY_CONFIG;
+    });
+  if (configConflicts.length) {
+    sendJson(res, 409, {
+      ok: false,
+      error: 'These tasks are declared in the profile config and cannot be replaced by an import: ' + configConflicts.join(', '),
+    });
+    return;
+  }
+  const summary = { add: plan.add.length, replace: plan.replace.length, skip: plan.skip.length };
+  if (body && body.dryRun) {
+    sendJson(res, 200, {
+      ok: true,
+      dryRun: true,
+      strategy: plan.strategy,
+      summary,
+      codeExecuting: hasCodeExecutingTask(plan.add.concat(plan.replace)),
+      unknownChannels: droppedChannels,
+    });
+    return;
+  }
+  const applied = applyImportPlan({ store, scheduler, plan });
+  if (applied.error) {
+    sendJson(res, 500, { ok: false, error: applied.error });
+    return;
+  }
+  sendJson(res, 200, {
+    ok: true,
+    imported: applied.imported.length,
+    summary,
+    unknownChannels: droppedChannels,
+    tasks: applied.imported,
+  });
+}
+
+/**
+ * Write an import plan. Every imported task is paused (the file's status is
+ * ignored) and every touched id is disarmed explicitly, because writing
+ * "paused" does not stop an already-armed croner job. A failed write rolls the
+ * store back so a partial import cannot survive.
+ */
+export function applyImportPlan({ store, scheduler, plan }) {
+  const imported = [];
+  const rollback = [];
+  const disarm = [];
+  try {
+    for (const task of plan.add) {
+      const before = store.get(task.id);
+      const created = store.set({ ...task, id: task.id || randomUUID(), status: 'paused', updatedAt: Date.now() });
+      imported.push(created);
+      rollback.push({ id: created.id, previous: before || null });
+      disarm.push(created.id);
+    }
+    for (const task of plan.replace) {
+      const before = store.get(task.id);
+      if (!before) continue;
+      const replaced = store.set({ ...task, id: task.id, status: 'paused', updatedAt: Date.now() });
+      imported.push(replaced);
+      rollback.push({ id: replaced.id, previous: before });
+      disarm.push(replaced.id);
+    }
+  } catch (writeErr) {
+    for (const entry of rollback.reverse()) {
+      try {
+        if (entry.previous) store.set(entry.previous);
+        else store.delete(entry.id);
+      } catch (rollbackErr) {
+        console.warn(`[dsh-cron] import rollback failed for task "${entry.id}":`, rollbackErr?.message || rollbackErr);
+      }
+    }
+    return { imported: [], error: `Import failed and was rolled back: ${writeErr.message}` };
+  }
+  // Disarm outside the write transaction: pauseTask is idempotent and a
+  // failure here must not undo a successful import.
+  for (const id of disarm) {
+    try {
+      scheduler.pauseTask(id);
+    } catch (err) {
+      console.error('[dsh-cron] import: could not pause task', id + ':', err.message);
+    }
+  }
+  return { imported };
+}
+

package/lib/api-webhook.js

@@ -0,0 +1,115 @@
+import { sendJson, readBody } from './http-utils.js';
+import { answerTelegramCallbackQuery, sendTelegramMessage, getDshDefaultTelegramCredentials } from './telegram.js';
+
+const NOT_ALLOWED = { ok: false, error: 'Method not allowed' };
+
+export async function handleTelegramWebhook({ store, scheduler, req, res }) {
+  if (req.method !== 'POST') {
+    sendJson(res, 405, NOT_ALLOWED);
+    return;
+  }
+  const { body, error } = await readBody(req, res);
+  if (error || !body) return;
+
+  const callbackQuery = body.callback_query;
+  if (!callbackQuery) {
+    sendJson(res, 200, { ok: true });
+    return;
+  }
+
+  const queryId = callbackQuery.id;
+  const data = String(callbackQuery.data || '');
+  const fromId = String(callbackQuery.from?.id || '');
+  const chatId = String(callbackQuery.message?.chat?.id || fromId);
+
+  const settings = typeof store.getSettings === 'function' ? store.getSettings() : {};
+  const defaults = getDshDefaultTelegramCredentials();
+  const botToken = settings.botToken || defaults.botToken;
+  const allowedChatId = String(settings.chatId || defaults.chatId || '').trim();
+
+  if (allowedChatId && chatId !== allowedChatId && fromId !== allowedChatId) {
+    console.warn(`[dsh-cron] unauthorized telegram callback from chat ${chatId} / user ${fromId}`);
+    if (botToken) {
+      await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: 'Unauthorized', showAlert: true });
+    }
+    sendJson(res, 403, { ok: false, error: 'Forbidden' });
+    return;
+  }
+
+  const parts = data.split(':');
+  if (parts[0] !== 'cron' || parts.length < 3) {
+    if (botToken) {
+      await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: 'Unknown action' });
+    }
+    sendJson(res, 200, { ok: true, ignored: true });
+    return;
+  }
+
+  const verb = parts[1];
+  const taskId = parts.slice(2).join(':');
+  const task = store.get(taskId);
+
+  if (!task) {
+    if (botToken) {
+      await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: 'Task not found', showAlert: true });
+    }
+    sendJson(res, 200, { ok: false, error: 'Task not found' });
+    return;
+  }
+
+  if (verb === 'run') {
+    try {
+      await scheduler.triggerManualRun(taskId);
+      if (botToken) {
+        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `🚀 Run triggered: ${task.title}` });
+      }
+    } catch (runErr) {
+      if (botToken) {
+        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `Run error: ${runErr.message}`, showAlert: true });
+      }
+    }
+  } else if (verb === 'pause') {
+    const isPaused = task.status === 'paused';
+    const newStatus = isPaused ? 'active' : 'paused';
+    if (typeof store.update === 'function') {
+      store.update(taskId, { status: newStatus });
+    } else {
+      store.set({ ...task, status: newStatus });
+    }
+    if (isPaused) {
+      scheduler.resume(taskId);
+      if (botToken) {
+        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `▶️ Resumed: ${task.title}` });
+      }
+    } else {
+      scheduler.pause(taskId);
+      if (botToken) {
+        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `⏸ Paused: ${task.title}` });
+      }
+    }
+  } else if (verb === 'log') {
+    const history = store.getHistory(taskId, 1);
+    const lastRun = history && history[0];
+    if (!lastRun) {
+      if (botToken) {
+        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `No runs recorded for ${task.title}`, showAlert: true });
+      }
+    } else {
+      const summary = `[${task.title}] Last run: ${lastRun.status} (${lastRun.durationMs}ms)\n${lastRun.output || lastRun.error || 'Empty output'}`;
+      if (botToken) {
+        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: summary.slice(0, 190) });
+        if (summary.length > 190 && chatId) {
+          await sendTelegramMessage({
+            botToken,
+            chatId,
+            text: `*Full Output for ${task.title}:*\n\`\`\`\n${summary.slice(0, 3000)}\n\`\`\``,
+            parseMode: 'Markdown',
+          }).catch(() => {});
+        }
+      }
+    }
+  }
+
+  sendJson(res, 200, { ok: true, verb, taskId });
+}
+

package/lib/api.js

@@ -6,24 +6,39 @@
  */
 
 import { randomUUID, createHash } from 'node:crypto';
-import { parseScheduleExpression, previewSchedule } from './scheduler.js';
+import { parseScheduleExpression } from './scheduler.js';
 import { normalizeTaskType, CODE_EXECUTING_TYPES } from './runtimes.js';
 import { CHANNEL_IDS, unknownChannelIds } from './channels.js';
 import { applyTaskPatch } from './task-patch.js';
 import { MANAGED_BY_CONFIG, configOwnedMessage } from './config-jobs.js';
 import { sendJson, rejectCrossOrigin, readBody, pickPatchableFields, SCRIPT_CONFIRM_HEADER } from './http-utils.js';
-import { answerTelegramCallbackQuery, sendTelegramMessage, getDshDefaultTelegramCredentials } from './telegram.js';
 import {
   validateTaskType,
   buildDuplicateTask,
-  buildTaskExport,
-  validateImportDocument,
-  planImport,
-  hasCodeExecutingTask,
-  IMPORT_STRATEGIES,
   RESERVED_TASK_IDS,
   PATCHABLE_TASK_FIELDS,
 } from './task-transfer.js';
+import {
+  handleTaskExport,
+  handleTaskImport,
+  applyImportPlan,
+} from './api-import-export.js';
+import { handleTelegramWebhook } from './api-webhook.js';
+import {
+  handleHeartbeatPing,
+  handleSchedulePreview,
+  handleDryRunTask,
+} from './api-helpers.js';
+
+export {
+  handleTaskExport,
+  handleTaskImport,
+  applyImportPlan,
+  handleTelegramWebhook,
+  handleHeartbeatPing,
+  handleSchedulePreview,
+  handleDryRunTask,
+};
 
 const NOT_FOUND = { ok: false, error: 'Task not found' };
 const NOT_ALLOWED = { ok: false, error: 'Method not allowed' };
@@ -230,136 +245,7 @@ function buildTaskRecord(store, body, taskType, parsed) {
   };
 }
 
-// --------------------------------------------------------- export / import
-
-function handleTaskExport({ store, res }) {
-  const doc = buildTaskExport(store.list({ status: 'all' }));
-  sendJson(res, 200, { ok: true, document: doc, count: doc.tasks.length });
-}
-
-async function handleTaskImport({ store, scheduler, req, res }) {
-  const { body, error } = await readBody(req, res);
-  if (error) return;
-  const strategy = IMPORT_STRATEGIES.includes(body && body.strategy) ? body.strategy : 'skip';
-  const checked = validateImportDocument(body && body.document);
-  if (!checked.ok) {
-    sendJson(res, 400, { ok: false, error: checked.error });
-    return;
-  }
-  // The import file is external input: importing code-executing tasks needs
-  // the same explicit confirmation that creating one over HTTP needs,
-  // otherwise a hand-edited file would bypass that gate (#86).
-  if (hasCodeExecutingTask(checked.tasks) && req.headers[SCRIPT_CONFIRM_HEADER] !== 'script') {
-    sendJson(res, 403, {
-      ok: false,
-      error: `Importing code-executing tasks over HTTP requires the ${SCRIPT_CONFIRM_HEADER}: script header`,
-    });
-    return;
-  }
-  // #121: an imported file may name a channel this build no longer has. The
-  // import stays tolerant by design (#42), but the loss is reported instead of
-  // being invisible.
-  const rawTasks = Array.isArray(body.document && body.document.tasks) ? body.document.tasks : [];
-  const droppedChannels = [];
-  for (const item of rawTasks) {
-    for (const id of unknownChannelIds(item.channels)) {
-      if (!droppedChannels.includes(id)) droppedChannels.push(id);
-    }
-  }
-  if (droppedChannels.length) {
-    console.warn('[dsh-cron] import: unknown channel ids were dropped: ' + droppedChannels.join(', '));
-  }
-  const existingIds = store.list({ status: 'all' }).map((x) => x.id);
-  const plan = planImport(checked.tasks, existingIds, strategy);
-  // Replacing a task the config owns would be undone at the next start, and
-  // the id could then hold two different tasks (#50).
-  const configConflicts = plan.replace
-    .map((item) => item.id)
-    .filter((taskId) => {
-      const stored = store.get(taskId);
-      return stored && stored.managedBy === MANAGED_BY_CONFIG;
-    });
-  if (configConflicts.length) {
-    sendJson(res, 409, {
-      ok: false,
-      error: 'These tasks are declared in the profile config and cannot be replaced by an import: ' + configConflicts.join(', '),
-    });
-    return;
-  }
-  const summary = { add: plan.add.length, replace: plan.replace.length, skip: plan.skip.length };
-  if (body && body.dryRun) {
-    sendJson(res, 200, {
-      ok: true,
-      dryRun: true,
-      strategy: plan.strategy,
-      summary,
-      codeExecuting: hasCodeExecutingTask(plan.add.concat(plan.replace)),
-      unknownChannels: droppedChannels,
-    });
-    return;
-  }
-  const applied = applyImportPlan({ store, scheduler, plan });
-  if (applied.error) {
-    sendJson(res, 500, { ok: false, error: applied.error });
-    return;
-  }
-  sendJson(res, 200, {
-    ok: true,
-    imported: applied.imported.length,
-    summary,
-    unknownChannels: droppedChannels,
-    tasks: applied.imported,
-  });
-}
-
-/**
- * Write an import plan. Every imported task is paused (the file's status is
- * ignored) and every touched id is disarmed explicitly, because writing
- * "paused" does not stop an already-armed croner job. A failed write rolls the
- * store back so a partial import cannot survive.
- */
-function applyImportPlan({ store, scheduler, plan }) {
-  const imported = [];
-  const rollback = [];
-  const disarm = [];
-  try {
-    for (const task of plan.add) {
-      const before = store.get(task.id);
-      const created = store.set({ ...task, id: task.id || randomUUID(), status: 'paused', updatedAt: Date.now() });
-      imported.push(created);
-      rollback.push({ id: created.id, previous: before || null });
-      disarm.push(created.id);
-    }
-    for (const task of plan.replace) {
-      const before = store.get(task.id);
-      if (!before) continue;
-      const replaced = store.set({ ...task, id: task.id, status: 'paused', updatedAt: Date.now() });
-      imported.push(replaced);
-      rollback.push({ id: replaced.id, previous: before });
-      disarm.push(replaced.id);
-    }
-  } catch (writeErr) {
-    for (const entry of rollback.reverse()) {
-      try {
-        if (entry.previous) store.set(entry.previous);
-        else store.delete(entry.id);
-      } catch (rollbackErr) {
-        console.warn(`[dsh-cron] import rollback failed for task "${entry.id}":`, rollbackErr?.message || rollbackErr);
-      }
-    }
-    return { imported: [], error: `Import failed and was rolled back: ${writeErr.message}` };
-  }
-  // Disarm outside the write transaction: pauseTask is idempotent and a
-  // failure here must not undo a successful import.
-  for (const id of disarm) {
-    try {
-      scheduler.pauseTask(id);
-    } catch (err) {
-      console.error('[dsh-cron] import: could not pause task', id + ':', err.message);
-    }
-  }
-  return { imported };
-}
+// export/import logic moved to ./api-import-export.js
 
 // ------------------------------------------------------------ single task
 
@@ -606,175 +492,4 @@ export async function handleExternalTaskRequest({ store, scheduler, req, res, ur
   sendJson(res, 405, NOT_ALLOWED);
 }
 
-export async function handleTelegramWebhook({ store, scheduler, req, res }) {
-  if (req.method !== 'POST') {
-    sendJson(res, 405, NOT_ALLOWED);
-    return;
-  }
-  const { body, error } = await readBody(req, res);
-  if (error || !body) return;
-
-  const callbackQuery = body.callback_query;
-  if (!callbackQuery) {
-    sendJson(res, 200, { ok: true });
-    return;
-  }
-
-  const queryId = callbackQuery.id;
-  const data = String(callbackQuery.data || '');
-  const fromId = String(callbackQuery.from?.id || '');
-  const chatId = String(callbackQuery.message?.chat?.id || fromId);
-
-  const settings = typeof store.getSettings === 'function' ? store.getSettings() : {};
-  const defaults = getDshDefaultTelegramCredentials();
-  const botToken = settings.botToken || defaults.botToken;
-  const allowedChatId = String(settings.chatId || defaults.chatId || '').trim();
-
-  if (allowedChatId && chatId !== allowedChatId && fromId !== allowedChatId) {
-    console.warn(`[dsh-cron] unauthorized telegram callback from chat ${chatId} / user ${fromId}`);
-    if (botToken) {
-      await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: 'Unauthorized', showAlert: true });
-    }
-    sendJson(res, 403, { ok: false, error: 'Forbidden' });
-    return;
-  }
-
-  const parts = data.split(':');
-  if (parts[0] !== 'cron' || parts.length < 3) {
-    if (botToken) {
-      await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: 'Unknown action' });
-    }
-    sendJson(res, 200, { ok: true, ignored: true });
-    return;
-  }
-
-  const verb = parts[1];
-  const taskId = parts.slice(2).join(':');
-  const task = store.get(taskId);
-
-  if (!task) {
-    if (botToken) {
-      await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: 'Task not found', showAlert: true });
-    }
-    sendJson(res, 200, { ok: false, error: 'Task not found' });
-    return;
-  }
-
-  if (verb === 'run') {
-    try {
-      await scheduler.triggerManualRun(taskId);
-      if (botToken) {
-        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `🚀 Run triggered: ${task.title}` });
-      }
-    } catch (runErr) {
-      if (botToken) {
-        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `Run error: ${runErr.message}`, showAlert: true });
-      }
-    }
-  } else if (verb === 'pause') {
-    const isPaused = task.status === 'paused';
-    const newStatus = isPaused ? 'active' : 'paused';
-    if (typeof store.update === 'function') {
-      store.update(taskId, { status: newStatus });
-    } else {
-      store.set({ ...task, status: newStatus });
-    }
-    if (isPaused) {
-      scheduler.resume(taskId);
-      if (botToken) {
-        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `▶️ Resumed: ${task.title}` });
-      }
-    } else {
-      scheduler.pause(taskId);
-      if (botToken) {
-        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `⏸ Paused: ${task.title}` });
-      }
-    }
-  } else if (verb === 'log') {
-    const history = store.getHistory(taskId, 1);
-    const lastRun = history && history[0];
-    if (!lastRun) {
-      if (botToken) {
-        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `No runs recorded for ${task.title}`, showAlert: true });
-      }
-    } else {
-      const summary = `[${task.title}] Last run: ${lastRun.status} (${lastRun.durationMs}ms)\n${lastRun.output || lastRun.error || 'Empty output'}`;
-      if (botToken) {
-        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: summary.slice(0, 190) });
-        if (summary.length > 190 && chatId) {
-          await sendTelegramMessage({
-            botToken,
-            chatId,
-            text: `*Full Output for ${task.title}:*\n\`\`\`\n${summary.slice(0, 3000)}\n\`\`\``,
-            parseMode: 'Markdown',
-          }).catch(() => {});
-        }
-      }
-    }
-  }
-
-  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 });
-  }
-}
+// webhook and helper endpoints moved to ./api-webhook.js and ./api-helpers.js