@goodandready/dsh-cron 0.2.9 → 0.2.11

package/lib/api.js

@@ -6,12 +6,13 @@
  */
 
 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';
 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,
@@ -54,6 +55,21 @@ export function createCronApiHandler(store, scheduler, collection) {
       const id = parts[2];
       const action = parts[3];
 
+      if (scope === 'telegram' && id === 'webhook') {
+        await handleTelegramWebhook({ store, scheduler, req, res });
+        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;
@@ -346,6 +362,31 @@ 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);
+    const search = url.searchParams.get('search') || '';
+    const result = typeof store.getArchivedRuns === 'function'
+      ? store.getArchivedRuns(id, { limit, offset, search })
+      : { runs: [], total: 0 };
+    sendJson(res, 200, { ok: true, taskId: id, ...result });
+    return;
+  }
+  if (req.method === 'GET' && action === 'stats') {
+    const stats = typeof store.getTaskStats === 'function' ? store.getTaskStats(id) : null;
+    sendJson(res, 200, { ok: true, taskId: id, stats });
+    return;
+  }
   if (req.method === 'GET' && (action === 'history' || !action)) {
     const limit = parseInt(url.searchParams.get('limit') || '20', 10);
     sendJson(res, 200, { ok: true, history: store.getHistory(id, limit) });
@@ -511,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];
 
@@ -550,3 +599,176 @@ 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 });
+  }
+}

package/lib/channels.js

@@ -7,7 +7,7 @@
  * collected so one broken channel cannot hide another.
  */
 
-import { formatTaskTelegramMessage, sendTelegramMessage } from './telegram.js';
+import { formatTaskTelegramMessage, sendTelegramMessage, createTelegramTaskKeyboard } from './telegram.js';
 import { createKanbanCard, shouldCreateKanbanCard } from './integrations.js';
 import { resolveTemplateText, truncateText } from './templates.js';
 
@@ -256,7 +256,8 @@ export const CHANNEL_HANDLERS = {
       ? messageTextFor('telegram', task, runInfo, settings)
       : formatTaskTelegramMessage(task, runInfo);
     try {
-      await sendTelegramMessage({ botToken, chatId, text, fetchFn: http, signal });
+      const replyMarkup = createTelegramTaskKeyboard(task, runInfo);
+      await sendTelegramMessage({ botToken, chatId, text, replyMarkup, fetchFn: http, signal });
     } catch (err) {
       if (isAbort(err)) throw new Error(`telegram: timed out after ${timeoutMs} ms`);
       throw err;