@goodandready/dsh-cron 0.3.24 → 0.3.26

package/lib/api-webhook.js

@@ -1,183 +1 @@
-import crypto from 'node:crypto';
-import { logger } from './logger.js';
-import { sendJson, readBody } from './http-utils.js';
-import { answerTelegramCallbackQuery, sendTelegramMessage, getDshDefaultTelegramCredentials } from './telegram.js';
-import { handleTelegramCommand } from './telegram-commands.js';
-import { bestEffort } from './best-effort.js';
-
-const NOT_ALLOWED = { ok: false, error: 'Method not allowed' };
-const seenUpdateIds = new Set();
-
-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 settings = typeof store.getSettings === 'function' ? store.getSettings() : {};
-  const defaults = getDshDefaultTelegramCredentials();
-  const botToken = settings.botToken || defaults.botToken;
-  const allowedChatId = String(settings.chatId || defaults.chatId || '').trim();
-
-  // Secret token verification (Issue #208) - fail-closed: secret MUST be configured
-  const webhookSecret = settings.telegramWebhookSecret || settings.webhookSecret || settings.secretToken || process.env.TELEGRAM_WEBHOOK_SECRET;
-  if (!webhookSecret) {
-    logger.warn('[dsh-cron] unauthorized telegram webhook: webhook secret is not configured (fail-closed)');
-    sendJson(res, 401, { ok: false, error: 'Unauthorized: webhook secret is not configured' });
-    return;
-  }
-  const headers = req.headers || {};
-  const receivedSecret = headers['x-telegram-bot-api-secret-token'] || headers['X-Telegram-Bot-Api-Secret-Token'];
-  if (!receivedSecret || typeof receivedSecret !== 'string') {
-    logger.warn('[dsh-cron] unauthorized telegram webhook: missing secret token header');
-    sendJson(res, 401, { ok: false, error: 'Unauthorized: missing secret token' });
-    return;
-  }
-  const secretBuf = Buffer.from(String(webhookSecret));
-  const receivedBuf = Buffer.from(String(receivedSecret));
-  if (secretBuf.length !== receivedBuf.length || !crypto.timingSafeEqual(secretBuf, receivedBuf)) {
-    logger.warn('[dsh-cron] unauthorized telegram webhook: invalid secret token');
-    sendJson(res, 401, { ok: false, error: 'Unauthorized: invalid secret token' });
-    return;
-  }
-
-  // Deduplicate updates by update_id (Issue #208)
-  if (body.update_id != null) {
-    if (seenUpdateIds.has(body.update_id)) {
-      sendJson(res, 200, { ok: true, duplicate: true });
-      return;
-    }
-    seenUpdateIds.add(body.update_id);
-    if (seenUpdateIds.size > 2000) {
-      const first = seenUpdateIds.values().next().value;
-      seenUpdateIds.delete(first);
-    }
-  }
-
-  // 1. Text command message (#175)
-  const message = body.message;
-  if (message && typeof message.text === 'string' && message.text.trim().startsWith('/')) {
-    const fromId = String(message.from?.id || '');
-    const chatId = String(message.chat?.id || fromId);
-    // Fail-closed: empty allowedChatId denies control (Issue #208)
-    if (!allowedChatId || (chatId !== allowedChatId && fromId !== allowedChatId)) {
-      logger.warn(`[dsh-cron] unauthorized telegram command from chat ${chatId} / user ${fromId} (allowedChatId: ${allowedChatId || 'NOT_CONFIGURED'})`);
-      sendJson(res, 403, { ok: false, error: 'Forbidden' });
-      return;
-    }
-    const result = await handleTelegramCommand({
-      store,
-      scheduler,
-      text: message.text,
-      chatId,
-      botToken,
-    });
-    sendJson(res, 200, result || { ok: true });
-    return;
-  }
-
-  // 2. Inline callback query (#137)
-  const callbackQuery = body.callback_query;
-  if (!callbackQuery) {
-    sendJson(res, 200, { ok: true, ignored: 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);
-
-  if (!allowedChatId || (chatId !== allowedChatId && fromId !== allowedChatId)) {
-    logger.warn(`[dsh-cron] unauthorized telegram callback from chat ${chatId} / user ${fromId} (allowedChatId: ${allowedChatId || 'NOT_CONFIGURED'})`);
-    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;
-  }
-
-  const isConfigTask = task.source === 'config' || task.origin === 'config' || task.readOnly || task.managedBy === 'config';
-  if ((verb === 'pause' || verb === 'resume') && isConfigTask) {
-    if (botToken) {
-      await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: 'Cannot modify config-owned task', showAlert: true });
-    }
-    sendJson(res, 400, { ok: false, error: 'Cannot modify config-owned task' });
-    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';
-    if (isPaused) {
-      scheduler.resumeTask(taskId);
-      if (botToken) {
-        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `▶️ Resumed: ${task.title}` });
-      }
-    } else {
-      scheduler.pauseTask(taskId, 'Paused via Telegram button');
-      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(() => {
-            bestEffort('telegram-full-output', () => {}, scheduler?.logger);
-          });
-        }
-      }
-    }
-  }
-
-  sendJson(res, 200, { ok: true, verb, taskId });
-}
-
+export * from './routes/api-webhook.js';

package/lib/api.js

@@ -1,178 +1 @@
-import { handleTaskWebhookRoute } from './api-task-webhook.js';
-import { sendJson, rejectCrossOrigin, redactTaskSecrets } from './http-utils.js';
-import {
-  handleTaskExport,
-  handleTaskImport,
-  applyImportPlan,
-} from './api-import-export.js';
-import { handleTelegramWebhook } from './api-webhook.js';
-import {
-  handleHeartbeatPing,
-  handleSchedulePreview,
-  handleDryRunTask,
-  handleScheduleTimeline,
-} from './api-helpers.js';
-import {
-  refuseConfigOwned,
-  handleTaskCollection,
-  createOrUpdateTask,
-  NOT_ALLOWED,
-  NOT_FOUND,
-} from './api-collection.js';
-import { handleTaskItem, deleteTask } from './api-item.js';
-import { handleItemPost } from './api-actions.js';
-
-export {
-  handleTaskExport,
-  handleTaskImport,
-  applyImportPlan,
-  handleTelegramWebhook,
-  handleHeartbeatPing,
-  handleSchedulePreview,
-  handleDryRunTask,
-  handleScheduleTimeline,
-  refuseConfigOwned,
-};
-
-/**
- * Shared implementation for the /dsh-cron/tasks... and /dsh-cron/action...
- * route families — the #66 alias is kept alive by the same code path instead
- * of a duplicated handler.
- *
- * IMPORTANT: prefix routes must be registered WITHOUT a trailing slash —
- * with one, the core degrades matching to exact-path equality and every
- * deeper path unrouted (#96). Exported for unit tests.
- */
-export function createCronApiHandler(store, scheduler, collection) {
-  const ctx = collection?.ctx;
-  return async function handleCronApi(req, res) {
-    try {
-      const apiToken = store?.getSettings?.()?.apiToken;
-      const authOptions = { apiToken, ctx };
-      const url = new URL(req.url, 'http://127.0.0.1');
-      const parts = url.pathname.split('/').filter(Boolean);
-      const scope = parts[1]; // 'tasks' | 'action' | 'heartbeat-ping'
-      const id = parts[2];
-      const action = parts[3];
-      const subAction = parts[4];
-
-      if (scope === 'telegram' && id === 'webhook') {
-        await handleTelegramWebhook({ store, scheduler, req, res });
-        return;
-      }
-      if (scope === 'webhook' && id) {
-        await handleTaskWebhookRoute({ store, scheduler, req, res, taskId: id });
-        return;
-      }
-
-      if ((scope === 'heartbeat' || scope === 'heartbeat-ping') && id) {
-        handleHeartbeatPing({ store, req, res, taskId: id, apiToken, ctx });
-        return;
-      }
-
-      if (scope === 'schedule' && id === 'preview') {
-        await handleSchedulePreview({ req, res, url, store, apiToken, ctx });
-        return;
-      }
-      if (scope === 'schedule' && id === 'timeline-24h') {
-        await handleScheduleTimeline({ req, res, url, store, scheduler, apiToken, ctx });
-        return;
-      }
-
-      if (!id) {
-        await handleTaskCollection({ store, scheduler, collection, req, res, url, scope, apiToken, ctx });
-        return;
-      }
-
-      if (rejectCrossOrigin(req, res, { apiToken, ctx })) return;
-
-      // Export/import are collection operations that live under /tasks/:id/…,
-      // so they are matched before the generic id handling below.
-      if (id === 'export') {
-        if (req.method !== 'GET') {
-          sendJson(res, 405, NOT_ALLOWED);
-          return;
-        }
-        handleTaskExport({ store, req, res });
-        return;
-      }
-      if (id === 'import') {
-        if (req.method !== 'POST') {
-          sendJson(res, 405, NOT_ALLOWED);
-          return;
-        }
-        await handleTaskImport({ store, scheduler, req, res });
-        return;
-      }
-
-      await handleTaskItem({ store, scheduler, req, res, url, id, action, subAction, apiToken, ctx });
-    } catch (err) {
-      sendJson(res, err.statusCode || 500, { ok: false, error: err.message });
-    }
-  };
-}
-
-// --------------------------------------------------------- external surface
-
-/**
- * Task operations for the token-guarded /dsh-cron/api/* prefix (#54). The shape
- * is deliberately small — list, read, create or update, delete, manual run —
- * and reuses the handlers above, so the confirmation gate for code-executing
- * tasks and the config-owned refusals are the same code, not a second copy.
- */
-export async function handleExternalTaskRequest({ store, scheduler, req, res, url, apiToken }) {
-  const parts = url.pathname.split('/').filter(Boolean); // dsh-cron, api, [tasks|heartbeat|schedule], :id?, :action?
-  if (parts[2] === 'webhook' && parts[3]) {
-    await handleTaskWebhookRoute({ store, scheduler, req, res, taskId: parts[3] });
-    return;
-  }
-  if (parts[2] === 'heartbeat' && parts[3]) {
-    handleHeartbeatPing({ store, req, res, taskId: parts[3], apiToken });
-    return;
-  }
-  if (parts[2] === 'schedule' && parts[3] === 'preview') {
-    await handleSchedulePreview({ req, res, url, store, apiToken });
-    return;
-  }
-  const id = parts[3];
-  const action = parts[4];
-  const subAction = parts[5];
-
-  if (!id) {
-    if (req.method === 'GET') {
-      const list = store
-        .list({ status: url.searchParams.get('status') || 'all', query: url.searchParams.get('query') || '' })
-        .map((task) => ({ ...redactTaskSecrets(task), running: scheduler.isRunning(task.id) }));
-      sendJson(res, 200, { ok: true, tasks: list });
-      return;
-    }
-    if (req.method === 'POST') {
-      await createOrUpdateTask({ store, scheduler, req, res, apiToken, ctx: undefined });
-      return;
-    }
-    sendJson(res, 405, NOT_ALLOWED);
-    return;
-  }
-
-  if (req.method === 'POST') {
-    const handled = await handleItemPost({ store, scheduler, req, res, url, id, action, subAction });
-    if (handled) return;
-  }
-  if (req.method === 'GET' && !action) {
-    const task = store.get(id);
-    if (!task) {
-      sendJson(res, 404, NOT_FOUND);
-      return;
-    }
-    sendJson(res, 200, { ok: true, task: { ...redactTaskSecrets(task), running: scheduler.isRunning(id) } });
-    return;
-  }
-  if (req.method === 'DELETE' && !action) {
-    deleteTask({ store, scheduler, res, id });
-    return;
-  }
-  sendJson(res, 405, NOT_ALLOWED);
-}
-
-// webhook and helper endpoints moved to ./api-webhook.js and ./api-helpers.js
-
+export * from './routes/api.js';

package/lib/artifacts.js

@@ -1,200 +1 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { createHash, randomUUID } from 'node:crypto';
-
-export const SAFE_MIME_TYPES = {
-  '.csv': 'text/csv; charset=utf-8',
-  '.json': 'application/json; charset=utf-8',
-  '.txt': 'text/plain; charset=utf-8',
-  '.log': 'text/plain; charset=utf-8',
-  '.md': 'text/markdown; charset=utf-8',
-  '.pdf': 'application/pdf',
-  '.png': 'image/png',
-  '.jpg': 'image/jpeg',
-  '.jpeg': 'image/jpeg',
-  '.webp': 'image/webp',
-};
-
-export class ArtifactManager {
-  constructor(baseDir) {
-    this.baseDir = baseDir || path.join(process.cwd(), 'artifacts');
-    this.maxArtifactBytes = 10 * 1024 * 1024; // 10 MiB per artifact
-    this.defaultRetentionDays = 7;
-    this.maxTotalStorageBytes = 50 * 1024 * 1024; // 50 MiB total quota
-  }
-
-  ensureDir() {
-    if (!fs.existsSync(this.baseDir)) {
-      fs.mkdirSync(this.baseDir, { recursive: true });
-    }
-  }
-
-  /**
-   * Sanitizes a requested filename to prevent path traversal (#321)
-   */
-  sanitizeFilename(name) {
-    if (!name || typeof name !== 'string') return 'artifact.txt';
-    const clean = path.basename(name).replace(/[\0\r\n\\\/]/g, '_');
-    return clean || 'artifact.txt';
-  }
-
-  getFilePath(artifactId, filename) {
-    if (!filename || filename.includes('..') || path.isAbsolute(filename)) {
-      throw new Error('Path traversal attempt detected in artifact storage');
-    }
-    const safeName = this.sanitizeFilename(filename);
-    const target = path.resolve(this.baseDir, `${artifactId}_${safeName}`);
-    // Security check: ensure path stays strictly within baseDir
-    if (!target.startsWith(path.resolve(this.baseDir) + path.sep)) {
-      throw new Error('Path traversal attempt detected in artifact storage');
-    }
-    return target;
-  }
-
-  /**
-   * Resolves safe MIME type for download/preview
-   */
-  resolveMimeType(filename) {
-    const ext = path.extname(filename).toLowerCase();
-    // Neutralize dangerous web formats to prevent XSS / script execution
-    if (ext === '.html' || ext === '.htm' || ext === '.svg' || ext === '.js') {
-      return 'text/plain; charset=utf-8';
-    }
-    return SAFE_MIME_TYPES[ext] || 'application/octet-stream';
-  }
-
-  /**
-   * Saves a new artifact file bound to a run (#321)
-   */
-  saveArtifact(runId, taskId, filename, contentBuffer) {
-    this.ensureDir();
-    const buf = Buffer.isBuffer(contentBuffer) ? contentBuffer : Buffer.from(contentBuffer || '', 'utf8');
-
-    if (buf.length > this.maxArtifactBytes) {
-      throw new Error(`Artifact size (${buf.length} bytes) exceeds limit of ${this.maxArtifactBytes} bytes`);
-    }
-
-    const artifactId = 'art_' + randomUUID().replace(/-/g, '').slice(0, 16);
-    const safeName = this.sanitizeFilename(filename);
-    const filePath = this.getFilePath(artifactId, safeName);
-
-    fs.writeFileSync(filePath, buf);
-
-    const sha256 = createHash('sha256').update(buf).digest('hex');
-    const mimeType = this.resolveMimeType(safeName);
-
-    return {
-      id: artifactId,
-      name: safeName,
-      sizeBytes: buf.length,
-      mimeType,
-      sha256,
-      runId,
-      taskId,
-      createdAt: Date.now(),
-      status: 'available',
-    };
-  }
-
-  /**
-   * Reads an artifact file buffer
-   */
-  readArtifact(artifactId, filename) {
-    const filePath = this.getFilePath(artifactId, filename);
-    if (!fs.existsSync(filePath)) {
-      return null;
-    }
-    return fs.readFileSync(filePath);
-  }
-
-  /**
-   * Generates a safe preview of the artifact content (first 64 KiB)
-   */
-  generatePreview(artifactId, filename) {
-    const buf = this.readArtifact(artifactId, filename);
-    if (!buf) return { ok: false, error: 'Artifact file not found on disk' };
-
-    const ext = path.extname(filename).toLowerCase();
-    const isText = ['.txt', '.csv', '.json', '.log', '.md'].includes(ext);
-
-    if (isText) {
-      const slice = buf.subarray(0, 64 * 1024);
-      return {
-        ok: true,
-        kind: 'text',
-        mimeType: this.resolveMimeType(filename),
-        content: slice.toString('utf8'),
-        truncated: buf.length > slice.length,
-        sizeBytes: buf.length,
-      };
-    }
-
-    return {
-      ok: true,
-      kind: 'binary',
-      mimeType: this.resolveMimeType(filename),
-      sizeBytes: buf.length,
-      preview: `[Binary file: ${filename} (${buf.length} bytes)]`,
-    };
-  }
-
-  /**
-   * Cleans up expired artifacts and enforces size quotas (#321)
-   */
-  cleanupArtifacts(store, { retentionDays = this.defaultRetentionDays, maxTotalBytes = this.maxTotalStorageBytes } = {}) {
-    if (!fs.existsSync(this.baseDir)) return { removedCount: 0, freedBytes: 0 };
-
-    const cutoff = Date.now() - retentionDays * 86400000;
-    let files = fs.readdirSync(this.baseDir);
-    let totalBytes = 0;
-    const fileStats = [];
-
-    for (const f of files) {
-      const p = path.join(this.baseDir, f);
-      try {
-        const stat = fs.statSync(p);
-        totalBytes += stat.size;
-        fileStats.push({ path: p, filename: f, mtime: stat.mtimeMs, size: stat.size });
-      } catch (e) {
-        // file unlinked concurrently
-      }
-    }
-
-    let removedCount = 0;
-    let freedBytes = 0;
-
-    // 1. Remove files older than retentionDays
-    for (const item of fileStats) {
-      if (item.mtime < cutoff) {
-        try {
-          fs.unlinkSync(item.path);
-          removedCount++;
-          freedBytes += item.size;
-          totalBytes -= item.size;
-        } catch (e) {
-          void e;
-        }
-      }
-    }
-
-    // 2. Enforce quota: remove oldest files if totalBytes > maxTotalBytes
-    if (totalBytes > maxTotalBytes) {
-      fileStats.sort((a, b) => a.mtime - b.mtime);
-      for (const item of fileStats) {
-        if (totalBytes <= maxTotalBytes) break;
-        if (fs.existsSync(item.path)) {
-          try {
-            fs.unlinkSync(item.path);
-            removedCount++;
-            freedBytes += item.size;
-            totalBytes -= item.size;
-          } catch (e) {
-          void e;
-        }
-        }
-      }
-    }
-
-    return { removedCount, freedBytes };
-  }
-}
+export * from './store/artifacts.js';