@iletai/nzb 1.7.4 → 1.8.0

package/dist/cron/scheduler.js

@@ -0,0 +1,159 @@
+import { Cron } from "croner";
+import { getCronJob, listCronJobs, recordCronRun, updateCronJob, } from "../store/cron-store.js";
+import { executeCronTask, notifyResult } from "./task-runner.js";
+const activeTimers = new Map();
+const runningJobs = new Set();
+/** Start the cron scheduler: load all enabled jobs from DB and schedule them. */
+export function startCronScheduler() {
+    const jobs = listCronJobs(true);
+    console.log(`[nzb] Cron scheduler starting with ${jobs.length} enabled job(s)`);
+    for (const job of jobs) {
+        scheduleJob(job);
+    }
+}
+/** Stop the cron scheduler: cancel all active timers. */
+export function stopCronScheduler() {
+    for (const [id, cron] of activeTimers) {
+        cron.stop();
+        console.log(`[nzb] Cron job '${id}' stopped`);
+    }
+    activeTimers.clear();
+    console.log("[nzb] Cron scheduler stopped");
+}
+/** Schedule (or reschedule) a single job. */
+export function scheduleJob(job) {
+    // Unschedule if already active
+    unscheduleJob(job.id);
+    if (!job.enabled)
+        return;
+    try {
+        const cron = new Cron(job.cronExpression, { name: job.id }, () => {
+            void runJob(job.id);
+        });
+        activeTimers.set(job.id, cron);
+        // Update nextRunAt in DB
+        const nextDate = cron.nextRun();
+        if (nextDate) {
+            updateCronJob(job.id, { nextRunAt: nextDate.toISOString() });
+        }
+        console.log(`[nzb] Cron job '${job.id}' (${job.name}) scheduled: ${job.cronExpression}`);
+    }
+    catch (err) {
+        console.error(`[nzb] Failed to schedule cron job '${job.id}':`, err instanceof Error ? err.message : err);
+    }
+}
+/** Unschedule a single job by ID. */
+export function unscheduleJob(jobId) {
+    const existing = activeTimers.get(jobId);
+    if (existing) {
+        existing.stop();
+        activeTimers.delete(jobId);
+    }
+}
+/** Manually trigger a job immediately. */
+export async function triggerJob(jobId) {
+    const job = getCronJob(jobId);
+    if (!job)
+        return `Job '${jobId}' not found.`;
+    return await runJob(jobId);
+}
+/** Get status of all scheduled jobs. */
+export function getSchedulerStatus() {
+    const allJobs = listCronJobs();
+    return allJobs.map((job) => {
+        const timer = activeTimers.get(job.id);
+        const nextRun = timer?.nextRun()?.toISOString() ?? job.nextRunAt;
+        return {
+            id: job.id,
+            name: job.name,
+            cronExpression: job.cronExpression,
+            taskType: job.taskType,
+            enabled: job.enabled,
+            active: activeTimers.has(job.id),
+            nextRun,
+        };
+    });
+}
+/** Internal: execute a job with retry, timeout, recording, and notification. */
+async function runJob(jobId) {
+    if (runningJobs.has(jobId)) {
+        console.log(`[nzb] Cron "${jobId}" already running, skipping`);
+        return `Job '${jobId}' already running.`;
+    }
+    const job = getCronJob(jobId);
+    if (!job)
+        return `Job '${jobId}' not found.`;
+    runningJobs.add(jobId);
+    console.log(`[nzb] Cron job '${job.id}' (${job.name}) executing...`);
+    const startedAt = new Date();
+    let lastError = null;
+    const maxAttempts = job.maxRetries + 1;
+    try {
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                // Apply timeout
+                const result = await withTaskTimeout(executeCronTask(job), job.timeoutMs);
+                // Record success
+                const finishedAt = new Date();
+                recordCronRun(jobId, "success", startedAt, finishedAt, result, null);
+                updateCronJob(jobId, { lastRunAt: finishedAt.toISOString() });
+                // Update nextRunAt
+                const timer = activeTimers.get(jobId);
+                if (timer) {
+                    const nextDate = timer.nextRun();
+                    if (nextDate) {
+                        updateCronJob(jobId, { nextRunAt: nextDate.toISOString() });
+                    }
+                }
+                console.log(`[nzb] Cron job '${job.id}' completed in ${finishedAt.getTime() - startedAt.getTime()}ms`);
+                await notifyResult(job, `✅ Completed\n${result}`);
+                return result;
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err.message : String(err);
+                const isTimeout = lastError.includes("timed out");
+                if (attempt < maxAttempts && !isTimeout) {
+                    console.log(`[nzb] Cron job '${job.id}' attempt ${attempt}/${maxAttempts} failed: ${lastError}. Retrying...`);
+                    // Brief delay before retry
+                    await new Promise((r) => setTimeout(r, 1000 * attempt));
+                    continue;
+                }
+                const finishedAt = new Date();
+                const status = isTimeout ? "timeout" : "error";
+                recordCronRun(jobId, status, startedAt, finishedAt, null, lastError);
+                updateCronJob(jobId, { lastRunAt: finishedAt.toISOString() });
+                // Update nextRunAt even on failure
+                const timer = activeTimers.get(jobId);
+                if (timer) {
+                    const nextDate = timer.nextRun();
+                    if (nextDate) {
+                        updateCronJob(jobId, { nextRunAt: nextDate.toISOString() });
+                    }
+                }
+                console.error(`[nzb] Cron job '${job.id}' failed: ${lastError}`);
+                await notifyResult(job, `❌ Failed: ${lastError}`);
+                return `Error: ${lastError}`;
+            }
+        }
+        return `Error: ${lastError ?? "Unknown error"}`;
+    }
+    finally {
+        runningJobs.delete(jobId);
+    }
+}
+/** Wrap a promise with a timeout. */
+function withTaskTimeout(promise, ms) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error(`Task timed out after ${ms}ms`));
+        }, ms);
+        promise.then((v) => {
+            clearTimeout(timer);
+            resolve(v);
+        }, (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+    });
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/cron/task-runner.js

@@ -0,0 +1,170 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
+import { freemem, totalmem } from "os";
+import { join } from "path";
+import { config } from "../config.js";
+import { DB_PATH, NZB_HOME } from "../paths.js";
+const BACKUPS_DIR = join(NZB_HOME, "backups");
+/** Notify result to Telegram if the job has notifyTelegram enabled. */
+export async function notifyResult(job, message) {
+    if (!job.notifyTelegram || !config.telegramEnabled)
+        return;
+    try {
+        const { sendProactiveMessage } = await import("../telegram/bot.js");
+        await sendProactiveMessage(`⏰ [${job.name}] ${message}`);
+    }
+    catch (err) {
+        console.error("[nzb] Cron notify failed:", err instanceof Error ? err.message : err);
+    }
+}
+/** Execute a cron task based on its taskType. Returns a result string. */
+export async function executeCronTask(job) {
+    const payload = JSON.parse(job.payload);
+    switch (job.taskType) {
+        case "prompt":
+            return await executePromptTask(payload);
+        case "health_check":
+            return await executeHealthCheckTask();
+        case "backup":
+            return await executeBackupTask();
+        case "notification":
+            return await executeNotificationTask(job, payload);
+        case "webhook":
+            return await executeWebhookTask(payload, job.timeoutMs);
+        default:
+            throw new Error(`Unknown task type: ${job.taskType}`);
+    }
+}
+async function executePromptTask(payload) {
+    const prompt = payload.prompt || "Scheduled check-in. Anything to report?";
+    try {
+        const { sendToOrchestrator } = await import("../copilot/orchestrator.js");
+        return await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => reject(new Error("Prompt task timed out after 120s")), 120_000);
+            let fullResponse = "";
+            sendToOrchestrator(`[Scheduled task] ${prompt}`, { type: "background" }, (text, done) => {
+                if (done) {
+                    clearTimeout(timeout);
+                    fullResponse = text;
+                    resolve(fullResponse);
+                }
+            });
+        });
+    }
+    catch (err) {
+        throw new Error(`Prompt task failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function executeHealthCheckTask() {
+    const checks = [];
+    // Memory check
+    const free = freemem();
+    const total = totalmem();
+    const usedPct = Math.round(((total - free) / total) * 100);
+    checks.push(`Memory: ${usedPct}% used (${formatBytes(free)} free / ${formatBytes(total)} total)`);
+    // Disk check (database size)
+    try {
+        if (existsSync(DB_PATH)) {
+            const dbSize = statSync(DB_PATH).size;
+            checks.push(`Database: ${formatBytes(dbSize)}`);
+        }
+    }
+    catch {
+        checks.push("Database: unable to check");
+    }
+    // Process uptime
+    const uptimeSeconds = Math.floor(process.uptime());
+    const hours = Math.floor(uptimeSeconds / 3600);
+    const minutes = Math.floor((uptimeSeconds % 3600) / 60);
+    checks.push(`Uptime: ${hours}h ${minutes}m`);
+    // Node.js memory usage
+    const mem = process.memoryUsage();
+    checks.push(`Heap: ${formatBytes(mem.heapUsed)} / ${formatBytes(mem.heapTotal)}`);
+    checks.push(`RSS: ${formatBytes(mem.rss)}`);
+    return checks.join("\n");
+}
+async function executeBackupTask() {
+    mkdirSync(BACKUPS_DIR, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backed = [];
+    // Backup database
+    if (existsSync(DB_PATH)) {
+        const dest = join(BACKUPS_DIR, `nzb-${timestamp}.db`);
+        copyFileSync(DB_PATH, dest);
+        backed.push(`Database → ${dest}`);
+    }
+    // Backup memories (WAL file if exists)
+    const walPath = DB_PATH + "-wal";
+    if (existsSync(walPath)) {
+        const dest = join(BACKUPS_DIR, `nzb-${timestamp}.db-wal`);
+        copyFileSync(walPath, dest);
+        backed.push(`WAL → ${dest}`);
+    }
+    // Prune old backups: keep last 10
+    try {
+        const files = readdirSync(BACKUPS_DIR)
+            .filter((f) => f.startsWith("nzb-") && f.endsWith(".db"))
+            .sort()
+            .reverse();
+        for (const old of files.slice(10)) {
+            const { unlinkSync } = await import("fs");
+            unlinkSync(join(BACKUPS_DIR, old));
+            // Also remove corresponding WAL
+            const walFile = old + "-wal";
+            if (existsSync(join(BACKUPS_DIR, walFile))) {
+                unlinkSync(join(BACKUPS_DIR, walFile));
+            }
+        }
+    }
+    catch {
+        // Prune failure is non-critical
+    }
+    return backed.length > 0 ? `Backup complete:\n${backed.join("\n")}` : "Nothing to backup";
+}
+async function executeNotificationTask(job, payload) {
+    const message = payload.message || "Scheduled notification";
+    if (config.telegramEnabled) {
+        const { sendProactiveMessage } = await import("../telegram/bot.js");
+        await sendProactiveMessage(message);
+        return `Notification sent: ${message}`;
+    }
+    return `Notification skipped (Telegram not configured): ${message}`;
+}
+async function executeWebhookTask(payload, timeoutMs) {
+    const url = payload.url;
+    if (!url)
+        throw new Error("Webhook task requires 'url' in payload");
+    const method = (payload.method || "GET").toUpperCase();
+    const headers = payload.headers || {};
+    const body = payload.body ? JSON.stringify(payload.body) : undefined;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            method,
+            headers: { "Content-Type": "application/json", ...headers },
+            body: method !== "GET" ? body : undefined,
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        const text = await response.text();
+        const truncated = text.length > 500 ? text.slice(0, 500) + "…" : text;
+        return `Webhook ${method} ${url} → ${response.status} ${response.statusText}\n${truncated}`;
+    }
+    catch (err) {
+        clearTimeout(timer);
+        if (err instanceof Error && err.name === "AbortError") {
+            throw new Error(`Webhook timed out after ${timeoutMs}ms`);
+        }
+        throw err;
+    }
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+}
+//# sourceMappingURL=task-runner.js.map

package/dist/daemon.js

@@ -7,6 +7,7 @@ import { getWorkers, initOrchestrator, setMessageLogger, setProactiveNotify, set
 import { PID_FILE_PATH } from "./paths.js";
 import { closeDb, getDb } from "./store/db.js";
 import { createBot, sendProactiveMessage, sendWorkerNotification, startBot, stopBot } from "./telegram/bot.js";
+import { startCronScheduler, stopCronScheduler } from "./cron/scheduler.js";
 import { checkForUpdate } from "./update.js";
 // Log the active CA bundle (injected by cli.ts via re-exec).
 if (process.env.NODE_EXTRA_CA_CERTS) {
@@ -134,6 +135,8 @@ async function main() {
     });
     // Start HTTP API for TUI
     await startApiServer();
+    // Start cron scheduler
+    startCronScheduler();
     // Start Telegram bot (if configured)
     if (config.telegramEnabled) {
         createBot();
@@ -194,6 +197,7 @@ async function shutdown() {
     forceTimer.unref();
     // Stop health check timer first
     stopHealthCheck();
+    stopCronScheduler();
     if (config.telegramEnabled) {
         try {
             await stopBot();
@@ -220,6 +224,7 @@ async function shutdown() {
 export async function restartDaemon() {
     console.log("[nzb] Restarting...");
     stopHealthCheck();
+    stopCronScheduler();
     const activeWorkers = getWorkers();
     const runningCount = Array.from(activeWorkers.values()).filter((w) => w.status === "running").length;
     if (runningCount > 0) {

package/dist/store/cron-store.js

@@ -0,0 +1,142 @@
+import { getDb } from "./db.js";
+export function createCronJob(input) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.prepare(`INSERT INTO cron_jobs (id, name, cron_expression, task_type, payload, enabled, notify_telegram, max_retries, timeout_ms, created_at, updated_at)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.id, input.name, input.cronExpression, input.taskType, input.payload ?? "{}", input.enabled !== false ? 1 : 0, input.notifyTelegram !== false ? 1 : 0, input.maxRetries ?? 0, input.timeoutMs ?? 300_000, now, now);
+    return getCronJob(input.id);
+}
+export function getCronJob(id) {
+    const db = getDb();
+    const row = db.prepare(`SELECT * FROM cron_jobs WHERE id = ?`).get(id);
+    return row ? mapCronJobRow(row) : undefined;
+}
+export function listCronJobs(enabledOnly = false) {
+    const db = getDb();
+    const sql = enabledOnly ? `SELECT * FROM cron_jobs WHERE enabled = 1` : `SELECT * FROM cron_jobs`;
+    const rows = db.prepare(sql).all();
+    return rows.map(mapCronJobRow);
+}
+export function updateCronJob(id, updates) {
+    const db = getDb();
+    const existing = getCronJob(id);
+    if (!existing)
+        return undefined;
+    const fields = [];
+    const values = [];
+    if (updates.name !== undefined) {
+        fields.push("name = ?");
+        values.push(updates.name);
+    }
+    if (updates.cronExpression !== undefined) {
+        fields.push("cron_expression = ?");
+        values.push(updates.cronExpression);
+    }
+    if (updates.taskType !== undefined) {
+        fields.push("task_type = ?");
+        values.push(updates.taskType);
+    }
+    if (updates.payload !== undefined) {
+        fields.push("payload = ?");
+        values.push(updates.payload);
+    }
+    if (updates.enabled !== undefined) {
+        fields.push("enabled = ?");
+        values.push(updates.enabled ? 1 : 0);
+    }
+    if (updates.notifyTelegram !== undefined) {
+        fields.push("notify_telegram = ?");
+        values.push(updates.notifyTelegram ? 1 : 0);
+    }
+    if (updates.maxRetries !== undefined) {
+        fields.push("max_retries = ?");
+        values.push(updates.maxRetries);
+    }
+    if (updates.timeoutMs !== undefined) {
+        fields.push("timeout_ms = ?");
+        values.push(updates.timeoutMs);
+    }
+    if (updates.lastRunAt !== undefined) {
+        fields.push("last_run_at = ?");
+        values.push(updates.lastRunAt);
+    }
+    if (updates.nextRunAt !== undefined) {
+        fields.push("next_run_at = ?");
+        values.push(updates.nextRunAt);
+    }
+    if (fields.length === 0)
+        return existing;
+    fields.push("updated_at = ?");
+    values.push(new Date().toISOString());
+    values.push(id);
+    db.prepare(`UPDATE cron_jobs SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+    return getCronJob(id);
+}
+export function deleteCronJob(id) {
+    const db = getDb();
+    const result = db.prepare(`DELETE FROM cron_jobs WHERE id = ?`).run(id);
+    if (result.changes > 0) {
+        db.prepare(`DELETE FROM cron_runs WHERE job_id = ?`).run(id);
+        return true;
+    }
+    return false;
+}
+export function recordCronRun(jobId, status, startedAt, finishedAt, result, error) {
+    const db = getDb();
+    const durationMs = finishedAt ? finishedAt.getTime() - startedAt.getTime() : null;
+    const info = db
+        .prepare(`INSERT INTO cron_runs (job_id, status, started_at, finished_at, result, error, duration_ms)
+		 VALUES (?, ?, ?, ?, ?, ?, ?)`)
+        .run(jobId, status, startedAt.toISOString(), finishedAt?.toISOString() ?? null, result, error, durationMs);
+    // Auto-prune: keep only 50 most recent runs per job
+    db.prepare(`DELETE FROM cron_runs WHERE job_id = ? AND id NOT IN (
+			SELECT id FROM cron_runs WHERE job_id = ? ORDER BY id DESC LIMIT 50
+		)`).run(jobId, jobId);
+    return {
+        id: Number(info.lastInsertRowid),
+        jobId,
+        status,
+        startedAt: startedAt.toISOString(),
+        finishedAt: finishedAt?.toISOString() ?? null,
+        result,
+        error,
+        durationMs,
+    };
+}
+export function getRecentRuns(jobId, limit = 10) {
+    const db = getDb();
+    const rows = db
+        .prepare(`SELECT * FROM cron_runs WHERE job_id = ? ORDER BY id DESC LIMIT ?`)
+        .all(jobId, limit);
+    return rows.map(mapCronRunRow);
+}
+function mapCronJobRow(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        cronExpression: row.cron_expression,
+        taskType: row.task_type,
+        payload: row.payload,
+        enabled: row.enabled === 1,
+        notifyTelegram: row.notify_telegram === 1,
+        maxRetries: row.max_retries,
+        timeoutMs: row.timeout_ms,
+        lastRunAt: row.last_run_at,
+        nextRunAt: row.next_run_at,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function mapCronRunRow(row) {
+    return {
+        id: row.id,
+        jobId: row.job_id,
+        status: row.status,
+        startedAt: row.started_at,
+        finishedAt: row.finished_at,
+        result: row.result,
+        error: row.error,
+        durationMs: row.duration_ms,
+    };
+}
+//# sourceMappingURL=cron-store.js.map

package/dist/store/db.js

@@ -82,6 +82,37 @@ export function getDb() {
         FOREIGN KEY(team_id) REFERENCES agent_teams(id)
       )
     `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS cron_jobs (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        cron_expression TEXT NOT NULL,
+        task_type TEXT NOT NULL,
+        payload TEXT NOT NULL DEFAULT '{}',
+        enabled INTEGER NOT NULL DEFAULT 1,
+        notify_telegram INTEGER NOT NULL DEFAULT 1,
+        max_retries INTEGER NOT NULL DEFAULT 0,
+        timeout_ms INTEGER NOT NULL DEFAULT 300000,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now')),
+        last_run_at TEXT,
+        next_run_at TEXT
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS cron_runs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        job_id TEXT NOT NULL,
+        status TEXT NOT NULL,
+        started_at TEXT DEFAULT (datetime('now')),
+        finished_at TEXT,
+        result TEXT,
+        error TEXT,
+        duration_ms INTEGER,
+        FOREIGN KEY(job_id) REFERENCES cron_jobs(id) ON DELETE CASCADE
+      )
+    `);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_cron_runs_job ON cron_runs(job_id, started_at)`);
         // Migrate: if the table already existed with a stricter CHECK, recreate it
         try {
             db.prepare(`INSERT INTO conversation_log (role, content, source) VALUES ('system', '__migration_test__', 'test')`).run();

package/dist/telegram/bot.js

@@ -10,6 +10,7 @@ import { config } from "../config.js";
 import { getPersistedUpdateOffset, isUpdateDuplicate, persistUpdateOffset } from "./dedup.js";
 import { registerCallbackHandlers } from "./handlers/callbacks.js";
 import { registerCommandHandlers } from "./handlers/commands.js";
+import { registerCronHandlers } from "./handlers/cron.js";
 import { sendFormattedReply } from "./handlers/helpers.js";
 import { registerInlineQueryHandler } from "./handlers/inline.js";
 import { registerMediaHandlers } from "./handlers/media.js";
@@ -104,6 +105,7 @@ export function createBot() {
     bot.use(mainMenu);
     // --- Handler registrations ---
     registerCallbackHandlers(bot);
+    registerCronHandlers(bot);
     registerInlineQueryHandler(bot);
     registerSmartSuggestionHandlers(bot);
     registerReactionHandlers(bot);
@@ -152,6 +154,7 @@ export async function startBot() {
             { command: "workers", description: "List active workers" },
             { command: "skills", description: "List installed skills" },
             { command: "memory", description: "Show stored memories" },
+            { command: "cron", description: "Manage cron jobs" },
             { command: "settings", description: "Bot settings" },
             { command: "restart", description: "Restart NZB" },
         ]);

package/dist/telegram/handlers/commands.js

@@ -5,6 +5,7 @@ import { restartDaemon } from "../../daemon.js";
 import { searchMemories } from "../../store/memory.js";
 import { chunkMessage } from "../formatter.js";
 import { buildSettingsText, formatMemoryList } from "../menus.js";
+import { sendCronMenu } from "./cron.js";
 import { getReactionHelpText } from "./reactions.js";
 export function registerCommandHandlers(bot, deps) {
     const { replyKeyboard, mainMenu, settingsMenu, getUptimeStr } = deps;
@@ -30,6 +31,7 @@ export function registerCommandHandlers(bot, deps) {
         "/memory — Stored memories\n" +
         "/skills — Installed skills\n" +
         "/workers — Active worker sessions\n" +
+        "/cron — Manage cron jobs\n" +
         "/restart — Restart NZB\n\n" +
         "⚡ Breakthrough Features:\n" +
         "• @bot query — Use me inline in any chat!\n" +
@@ -194,6 +196,9 @@ export function registerCommandHandlers(bot, deps) {
     bot.command("settings", async (ctx) => {
         await ctx.reply(buildSettingsText(getUptimeStr), { reply_markup: settingsMenu });
     });
+    bot.command("cron", async (ctx) => {
+        await sendCronMenu(ctx);
+    });
     // Reply keyboard button handlers — intercept before general text handler
     bot.hears("📊 Status", async (ctx) => {
         const workers = Array.from(getWorkers().values());