@iletai/nzb 1.7.3 → 1.8.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

@@ -8,6 +8,7 @@ export function getDb() {
         ensureNZBHome();
         db = new Database(DB_PATH);
         db.pragma("journal_mode = WAL");
+        db.pragma("busy_timeout = 5000");
         db.exec(`
       CREATE TABLE IF NOT EXISTS worker_sessions (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -81,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";
@@ -25,6 +26,8 @@ const startedAt = Date.now();
 const INITIAL_POLL_RETRY_DELAY = 5000;
 const MAX_POLL_RETRY_DELAY = 300_000; // 5 minutes
 let pollRetryDelay = INITIAL_POLL_RETRY_DELAY;
+let consecutivePollingFailures = 0;
+const MAX_CONSECUTIVE_POLLING_FAILURES = 10;
 // Direct-connection HTTPS agent for Telegram API requests.
 // This bypasses corporate proxy (HTTP_PROXY/HTTPS_PROXY env vars) without
 // modifying process.env, so other services (Copilot SDK, MCP, npm) are unaffected.
@@ -102,6 +105,7 @@ export function createBot() {
     bot.use(mainMenu);
     // --- Handler registrations ---
     registerCallbackHandlers(bot);
+    registerCronHandlers(bot);
     registerInlineQueryHandler(bot);
     registerSmartSuggestionHandlers(bot);
     registerReactionHandlers(bot);
@@ -150,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" },
         ]);
@@ -177,15 +182,21 @@ export async function startBot() {
         ...(savedOffset ? { offset: savedOffset + 1 } : {}),
         onStart: () => {
             console.log("[nzb] Telegram bot connected");
+            consecutivePollingFailures = 0;
             pollRetryDelay = INITIAL_POLL_RETRY_DELAY;
             void logInfo(`🚀 NZB v${process.env.npm_package_version || "?"} started (model: ${config.copilotModel})`);
         },
     })
         .catch(async (err) => {
+        consecutivePollingFailures++;
         if (err?.error_code === 401) {
             console.error("[nzb] Warning: Telegram bot token is invalid or expired. Run 'nzb setup' and re-enter your bot token from @BotFather.");
             return; // Unrecoverable — don't retry
         }
+        if (consecutivePollingFailures >= MAX_CONSECUTIVE_POLLING_FAILURES) {
+            console.error(`[nzb] Telegram polling failed ${consecutivePollingFailures} consecutive times. Stopping retry attempts. Restart NZB to try again.`);
+            return;
+        }
         if (err?.error_code === 409) {
             console.error(`[nzb] Warning: Telegram polling conflict (409). Restarting polling in ${pollRetryDelay / 1000}s...`);
         }

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());

package/dist/telegram/handlers/cron.js

@@ -0,0 +1,354 @@
+import { InlineKeyboard } from "grammy";
+import { scheduleJob, triggerJob, unscheduleJob } from "../../cron/scheduler.js";
+import { deleteCronJob, getCronJob, getRecentRuns, listCronJobs, updateCronJob, } from "../../store/cron-store.js";
+import { isMessageNotModifiedError } from "../formatter.js";
+const JOBS_PER_PAGE = 5;
+// ── Keyboard builders ────────────────────────────────────────────────
+function buildCronMainMenu() {
+    return new InlineKeyboard()
+        .text("📋 List Jobs", "cron:list")
+        .text("➕ Add Job", "cron:add")
+        .row()
+        .text("📊 Overview", "cron:overview");
+}
+function buildJobListKeyboard(jobs, page, totalPages) {
+    const kb = new InlineKeyboard();
+    const start = page * JOBS_PER_PAGE;
+    const pageJobs = jobs.slice(start, start + JOBS_PER_PAGE);
+    for (const job of pageJobs) {
+        const toggleLabel = job.enabled ? "⏸" : "▶️";
+        kb.text(`${toggleLabel} ${job.name}`, `cron:toggle:${job.id}`)
+            .text("▶ Run", `cron:trigger:${job.id}`)
+            .text("📊", `cron:history:${job.id}`)
+            .text("🗑", `cron:delete:${job.id}`)
+            .row();
+    }
+    if (totalPages > 1) {
+        if (page > 0)
+            kb.text("⬅️ Prev", `cron:list:${page - 1}`);
+        if (page < totalPages - 1)
+            kb.text("➡️ Next", `cron:list:${page + 1}`);
+        kb.row();
+    }
+    kb.text("🔙 Back", "cron:back");
+    return kb;
+}
+// ── Text formatters ──────────────────────────────────────────────────
+function formatJobLine(job, index) {
+    const status = job.enabled ? "✅" : "⏸";
+    const nextRun = job.nextRunAt
+        ? new Date(job.nextRunAt).toLocaleString("en-US", {
+            month: "short",
+            day: "numeric",
+            hour: "2-digit",
+            minute: "2-digit",
+        })
+        : "—";
+    return (`${index}. ${status} ${job.name}\n` +
+        `   ⏰ ${job.cronExpression} | 🏷 ${job.taskType}\n` +
+        `   📅 Next: ${nextRun}`);
+}
+function buildJobListText(jobs, page, totalPages) {
+    if (jobs.length === 0) {
+        return "📋 Cron Jobs\n\nNo jobs configured.\nUse ➕ Add Job or ask NZB to create one.";
+    }
+    const start = page * JOBS_PER_PAGE;
+    const pageJobs = jobs.slice(start, start + JOBS_PER_PAGE);
+    const enabled = jobs.filter((j) => j.enabled).length;
+    let text = `📋 Cron Jobs — ${jobs.length} total (${enabled} active, ${jobs.length - enabled} paused)\n\n`;
+    text += pageJobs.map((j, i) => formatJobLine(j, start + i + 1)).join("\n\n");
+    if (totalPages > 1) {
+        text += `\n\n📄 Page ${page + 1}/${totalPages}`;
+    }
+    return text;
+}
+function formatRunStatus(status) {
+    switch (status) {
+        case "success":
+            return "✅";
+        case "error":
+            return "❌";
+        case "timeout":
+            return "⏱";
+        case "running":
+            return "🔄";
+        default:
+            return "⬜";
+    }
+}
+// ── Shared list handler ──────────────────────────────────────────────
+async function showCronList(ctx, page, isEdit) {
+    const jobs = listCronJobs();
+    const totalPages = Math.max(1, Math.ceil(jobs.length / JOBS_PER_PAGE));
+    const safePage = Math.min(page, totalPages - 1);
+    const text = buildJobListText(jobs, safePage, totalPages);
+    const keyboard = buildJobListKeyboard(jobs, safePage, totalPages);
+    if (isEdit) {
+        await ctx.editMessageText(text, { reply_markup: keyboard });
+    }
+    else {
+        await ctx.reply(text, { reply_markup: keyboard });
+    }
+}
+// ── Public: /cron command entry point ────────────────────────────────
+/** Send the main cron menu. Called from /cron command handler. */
+export async function sendCronMenu(ctx) {
+    await ctx.reply("⏰ Cron Task Manager", { reply_markup: buildCronMainMenu() });
+}
+// ── Public: register all cron callback handlers ──────────────────────
+export function registerCronHandlers(bot) {
+    // List all jobs
+    bot.callbackQuery("cron:list", async (ctx) => {
+        try {
+            await ctx.answerCallbackQuery();
+            await showCronList(ctx, 0, true);
+        }
+        catch (err) {
+            if (!isMessageNotModifiedError(err)) {
+                console.error("[nzb] Cron list error:", err instanceof Error ? err.message : err);
+            }
+        }
+    });
+    // Paginated list
+    bot.callbackQuery(/^cron:list:(\d+)$/, async (ctx) => {
+        try {
+            const page = parseInt(ctx.match[1], 10);
+            await ctx.answerCallbackQuery();
+            await showCronList(ctx, page, true);
+        }
+        catch (err) {
+            if (!isMessageNotModifiedError(err)) {
+                console.error("[nzb] Cron list page error:", err instanceof Error ? err.message : err);
+            }
+        }
+    });
+    // Add job guidance
+    bot.callbackQuery("cron:add", async (ctx) => {
+        try {
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText("➕ Add Cron Job\n\n" +
+                "Send a message to NZB describing the task:\n\n" +
+                "Examples:\n" +
+                '• "Schedule a daily backup at midnight"\n' +
+                '• "Remind me every Monday at 9am to check emails"\n' +
+                '• "Run health check every 5 minutes"\n\n' +
+                "NZB will create the cron job automatically.", { reply_markup: new InlineKeyboard().text("🔙 Back", "cron:back") });
+        }
+        catch (err) {
+            if (!isMessageNotModifiedError(err)) {
+                console.error("[nzb] Cron add error:", err instanceof Error ? err.message : err);
+            }
+        }
+    });
+    // Overview with recent activity
+    bot.callbackQuery("cron:overview", async (ctx) => {
+        try {
+            const jobs = listCronJobs();
+            const enabled = jobs.filter((j) => j.enabled).length;
+            let text = `📊 Cron Overview\n\nTotal: ${jobs.length} jobs\n✅ Active: ${enabled}\n⏸ Paused: ${jobs.length - enabled}\n`;
+            if (jobs.length > 0) {
+                text += "\nRecent activity:\n";
+                for (const job of jobs.slice(0, 5)) {
+                    const runs = getRecentRuns(job.id, 1);
+                    const lastRun = runs[0];
+                    if (lastRun) {
+                        const time = new Date(lastRun.startedAt).toLocaleString("en-US", {
+                            month: "short",
+                            day: "numeric",
+                            hour: "2-digit",
+                            minute: "2-digit",
+                        });
+                        text += `${formatRunStatus(lastRun.status)} ${job.name} — ${time}\n`;
+                    }
+                    else {
+                        text += `⬜ ${job.name} — never run\n`;
+                    }
+                }
+            }
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText(text, {
+                reply_markup: new InlineKeyboard().text("📋 List Jobs", "cron:list").row().text("🔙 Back", "cron:back"),
+            });
+        }
+        catch (err) {
+            if (!isMessageNotModifiedError(err)) {
+                console.error("[nzb] Cron overview error:", err instanceof Error ? err.message : err);
+                await ctx
+                    .answerCallbackQuery({ text: "Error loading overview", show_alert: true })
+                    .catch(() => { });
+            }
+        }
+    });
+    // Toggle enable/disable
+    bot.callbackQuery(/^cron:toggle:(.+)$/, async (ctx) => {
+        try {
+            const jobId = ctx.match[1];
+            const job = getCronJob(jobId);
+            if (!job) {
+                await ctx.answerCallbackQuery({ text: "Job not found", show_alert: true });
+                return;
+            }
+            const newEnabled = !job.enabled;
+            updateCronJob(jobId, { enabled: newEnabled });
+            if (newEnabled) {
+                const updated = getCronJob(jobId);
+                if (updated)
+                    scheduleJob(updated);
+            }
+            else {
+                unscheduleJob(jobId);
+            }
+            await ctx.answerCallbackQuery(`${job.name} → ${newEnabled ? "enabled ✅" : "disabled ⏸"}`);
+            await showCronList(ctx, 0, true);
+        }
+        catch (err) {
+            if (!isMessageNotModifiedError(err)) {
+                console.error("[nzb] Cron toggle error:", err instanceof Error ? err.message : err);
+                await ctx
+                    .answerCallbackQuery({ text: "Error toggling job", show_alert: true })
+                    .catch(() => { });
+            }
+        }
+    });
+    // Trigger job manually
+    bot.callbackQuery(/^cron:trigger:(.+)$/, async (ctx) => {
+        try {
+            const jobId = ctx.match[1];
+            const job = getCronJob(jobId);
+            if (!job) {
+                await ctx.answerCallbackQuery({ text: "Job not found", show_alert: true });
+                return;
+            }
+            await ctx.answerCallbackQuery(`▶ Running "${job.name}"...`);
+            // Fire-and-forget — don't block the callback response
+            triggerJob(jobId)
+                .then(async (result) => {
+                try {
+                    const truncated = result.length > 200 ? result.slice(0, 200) + "…" : result;
+                    await ctx.reply(`▶ ${job.name} completed:\n${truncated}`);
+                }
+                catch { }
+            })
+                .catch(async (err) => {
+                try {
+                    await ctx.reply(`❌ ${job.name} failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                catch { }
+            });
+        }
+        catch (err) {
+            console.error("[nzb] Cron trigger error:", err instanceof Error ? err.message : err);
+            await ctx
+                .answerCallbackQuery({ text: "Error triggering job", show_alert: true })
+                .catch(() => { });
+        }
+    });
+    // Delete confirmation — must be registered BEFORE the general delete handler
+    bot.callbackQuery(/^cron:delete:confirm:(.+)$/, async (ctx) => {
+        try {
+            const jobId = ctx.match[1];
+            const job = getCronJob(jobId);
+            const name = job?.name ?? jobId;
+            unscheduleJob(jobId);
+            const deleted = deleteCronJob(jobId);
+            if (deleted) {
+                await ctx.answerCallbackQuery(`🗑 Deleted: ${name}`);
+            }
+            else {
+                await ctx.answerCallbackQuery({ text: "Job already deleted", show_alert: true });
+            }
+            await showCronList(ctx, 0, true);
+        }
+        catch (err) {
+            if (!isMessageNotModifiedError(err)) {
+                console.error("[nzb] Cron delete error:", err instanceof Error ? err.message : err);
+                await ctx
+                    .answerCallbackQuery({ text: "Error deleting job", show_alert: true })
+                    .catch(() => { });
+            }
+        }
+    });
+    // Delete prompt (show confirmation dialog)
+    bot.callbackQuery(/^cron:delete:(.+)$/, async (ctx) => {
+        try {
+            const jobId = ctx.match[1];
+            // Skip if this is actually a confirm callback (shouldn't happen due to ordering, but safety check)
+            if (jobId.startsWith("confirm:"))
+                return;
+            const job = getCronJob(jobId);
+            if (!job) {
+                await ctx.answerCallbackQuery({ text: "Job not found", show_alert: true });
+                return;
+            }
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText(`🗑 Delete "${job.name}"?\n\n` +
+                `⏰ ${job.cronExpression}\n` +
+                `🏷 Type: ${job.taskType}\n` +
+                `Status: ${job.enabled ? "✅ Active" : "⏸ Paused"}\n\n` +
+                "⚠️ This permanently removes the job and its run history.", {
+                reply_markup: new InlineKeyboard()
+                    .text("✅ Yes, delete", `cron:delete:confirm:${job.id}`)
+                    .text("❌ Cancel", "cron:list"),
+            });
+        }
+        catch (err) {
+            if (!isMessageNotModifiedError(err)) {
+                console.error("[nzb] Cron delete prompt error:", err instanceof Error ? err.message : err);
+            }
+        }
+    });
+    // History — show recent runs for a job
+    bot.callbackQuery(/^cron:history:(.+)$/, async (ctx) => {
+        try {
+            const jobId = ctx.match[1];
+            const job = getCronJob(jobId);
+            if (!job) {
+                await ctx.answerCallbackQuery({ text: "Job not found", show_alert: true });
+                return;
+            }
+            const runs = getRecentRuns(jobId, 10);
+            let text = `📊 History: ${job.name}\n⏰ ${job.cronExpression}\n\n`;
+            if (runs.length === 0) {
+                text += "No runs recorded yet.";
+            }
+            else {
+                for (const run of runs) {
+                    const time = new Date(run.startedAt).toLocaleString("en-US", {
+                        month: "short",
+                        day: "numeric",
+                        hour: "2-digit",
+                        minute: "2-digit",
+                    });
+                    const duration = run.durationMs !== null ? ` (${(run.durationMs / 1000).toFixed(1)}s)` : "";
+                    const errorInfo = run.error ? `\n   ⚠️ ${run.error.slice(0, 80)}` : "";
+                    text += `${formatRunStatus(run.status)} ${time}${duration}${errorInfo}\n`;
+                }
+            }
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText(text, {
+                reply_markup: new InlineKeyboard().text("🔙 Back to list", "cron:list"),
+            });
+        }
+        catch (err) {
+            if (!isMessageNotModifiedError(err)) {
+                console.error("[nzb] Cron history error:", err instanceof Error ? err.message : err);
+                await ctx
+                    .answerCallbackQuery({ text: "Error loading history", show_alert: true })
+                    .catch(() => { });
+            }
+        }
+    });
+    // Back to main cron menu
+    bot.callbackQuery("cron:back", async (ctx) => {
+        try {
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText("⏰ Cron Task Manager", { reply_markup: buildCronMainMenu() });
+        }
+        catch (err) {
+            if (!isMessageNotModifiedError(err)) {
+                console.error("[nzb] Cron back error:", err instanceof Error ? err.message : err);
+            }
+        }
+    });
+}
+//# sourceMappingURL=cron.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@iletai/nzb",
-    "version": "1.7.3",
+    "version": "1.8.0",
     "description": "NZB — a personal AI assistant for developers, built on the GitHub Copilot SDK",
     "bin": {
         "nzb": "dist/cli.js"
@@ -54,6 +54,7 @@
         "@grammyjs/runner": "^2.0.3",
         "@grammyjs/transformer-throttler": "^1.2.1",
         "better-sqlite3": "^12.6.2",
+        "croner": "^10.0.1",
         "dotenv": "^17.3.1",
         "express": "^5.2.1",
         "grammy": "^1.40.0",