@iletai/nzb 1.8.0 → 1.8.2

package/dist/api/server.js

@@ -7,6 +7,7 @@ import { listSkills, removeSkill } from "../copilot/skills.js";
 import { restartDaemon } from "../daemon.js";
 import { API_TOKEN_PATH, ensureNZBHome } from "../paths.js";
 import { searchMemories } from "../store/memory.js";
+import { sendVoice } from "../telegram/bot.js";
 import { sendPhoto } from "../telegram/bot.js";
 // Ensure token file exists (generate on first run)
 let apiToken = null;
@@ -211,6 +212,32 @@ app.post("/send-photo", async (req, res) => {
         res.status(500).json({ error: msg });
     }
 });
+// Send a voice/audio file to Telegram (protected by bearer token auth middleware)
+app.post("/send-voice", async (req, res) => {
+    const { voice, caption, chat_id } = req.body;
+    if (!voice || typeof voice !== "string") {
+        res.status(400).json({ error: "Missing 'voice' (file path) in request body" });
+        return;
+    }
+    // Only allow local file paths (no URLs for voice)
+    if (voice.startsWith("http://") || voice.startsWith("https://")) {
+        res.status(400).json({ error: "Only local file paths are allowed for voice" });
+        return;
+    }
+    const chatId = chat_id ? parseInt(chat_id, 10) : undefined;
+    if (chat_id && (isNaN(chatId) || chatId === 0)) {
+        res.status(400).json({ error: "Invalid 'chat_id'" });
+        return;
+    }
+    try {
+        await sendVoice(voice, caption, chatId);
+        res.json({ status: "sent" });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        res.status(500).json({ error: msg });
+    }
+});
 // Global error handler — catch unhandled Express errors
 app.use((err, _req, res, _next) => {
     console.error("[nzb] Express error:", err.message);

package/dist/cli.js

@@ -45,6 +45,8 @@ Commands:
   tui         Connect to the daemon via terminal UI
   setup       Interactive first-run configuration
   update      Check for updates and install the latest version
+  update check  Check for updates without installing
+  update --force  Force reinstall the latest version
   cron        Manage scheduled cron jobs
   help        Show this help message
 
@@ -77,21 +79,48 @@ switch (command) {
         await import("./setup.js");
         break;
     case "update": {
-        const { checkForUpdate, performUpdate } = await import("./update.js");
+        const { checkForUpdate, performUpdate, performForceUpdate } = await import("./update.js");
+        const updateArgs = args.slice(1);
+        const subCmd = updateArgs[0];
+        const force = updateArgs.includes("--force");
+        // `nzb update check` — check only, don't install
+        if (subCmd === "check") {
+            const check = await checkForUpdate();
+            if (!check.checkSucceeded) {
+                console.error("Warning: Could not reach the npm registry. Check your network and try again.");
+                process.exit(1);
+            }
+            if (check.updateAvailable) {
+                console.log(`Update available: v${check.current} → v${check.latest}`);
+                if (check.publishedAt) {
+                    console.log(`Published: ${new Date(check.publishedAt).toLocaleDateString()}`);
+                }
+            }
+            else {
+                console.log(`nzb v${check.current} is already the latest version.`);
+            }
+            break;
+        }
+        // `nzb update` or `nzb update --force` — check and install
         const check = await checkForUpdate();
         if (!check.checkSucceeded) {
             console.error("Warning: Could not reach the npm registry. Check your network and try again.");
             process.exit(1);
         }
-        if (!check.updateAvailable) {
+        if (!check.updateAvailable && !force) {
             console.log(`nzb v${check.current} is already the latest version.`);
             break;
         }
-        console.log(`Update available: v${check.current} → v${check.latest}`);
+        if (check.updateAvailable) {
+            console.log(`Update available: v${check.current} → v${check.latest}`);
+        }
+        else if (force) {
+            console.log(`Force reinstalling nzb v${check.current}...`);
+        }
         console.log("Installing...");
-        const result = await performUpdate();
+        const result = force ? await performForceUpdate() : await performUpdate();
         if (result.ok) {
-            console.log(`Updated to v${check.latest}`);
+            console.log(check.updateAvailable ? `Updated to v${check.latest}` : `Reinstalled v${check.current}`);
         }
         else {
             console.error(`Update failed: ${result.output}`);

package/dist/copilot/tools.js

@@ -855,6 +855,56 @@ export function createTools(deps) {
                 return `Restarting NZB${reason}. I'll be back in a few seconds.`;
             },
         }),
+        defineTool("check_update", {
+            description: "Check for NZB updates and optionally apply them. " +
+                "Use 'check' to see if updates are available. " +
+                "Use 'update' to install the latest version and restart.",
+            parameters: z.object({
+                action: z.enum(["check", "update"]).describe("'check' to check for updates, 'update' to install and restart"),
+            }),
+            handler: async (args) => {
+                try {
+                    const { checkForUpdate, performUpdate, getChangelog } = await import("../update.js");
+                    if (args.action === "check") {
+                        const result = await checkForUpdate();
+                        if (!result.checkSucceeded) {
+                            return "Could not reach the npm registry. Network may be unavailable.";
+                        }
+                        if (!result.updateAvailable) {
+                            return `NZB v${result.current} is already the latest version.`;
+                        }
+                        const changelog = await getChangelog(5);
+                        const changelogText = changelog.length > 0
+                            ? "\n\nRecent versions:\n" + changelog.map((e) => `• v${e.version} (${e.date})`).join("\n")
+                            : "";
+                        return `Update available: v${result.current} → v${result.latest}${changelogText}`;
+                    }
+                    // action === "update"
+                    const result = await checkForUpdate();
+                    if (!result.checkSucceeded) {
+                        return "Could not reach the npm registry. Network may be unavailable.";
+                    }
+                    if (!result.updateAvailable) {
+                        return `NZB v${result.current} is already the latest version. No update needed.`;
+                    }
+                    const updateResult = await performUpdate();
+                    if (!updateResult.ok) {
+                        return `Update failed: ${updateResult.output}`;
+                    }
+                    // Schedule restart after returning the response
+                    const { restartDaemon } = await import("../daemon.js");
+                    setTimeout(() => {
+                        restartDaemon().catch((err) => {
+                            console.error("[nzb] Post-update restart failed:", err);
+                        });
+                    }, 1000);
+                    return `Updated NZB to v${result.latest}. Restarting now...`;
+                }
+                catch (err) {
+                    return `Update error: ${err instanceof Error ? err.message : String(err)}`;
+                }
+            },
+        }),
     ];
 }
 function formatAge(date) {

package/dist/cron/task-runner.js

@@ -1,4 +1,5 @@
-import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
+import { execSync } from "child_process";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from "fs";
 import { freemem, totalmem } from "os";
 import { join } from "path";
 import { config } from "../config.js";
@@ -30,6 +31,8 @@ export async function executeCronTask(job) {
             return await executeNotificationTask(job, payload);
         case "webhook":
             return await executeWebhookTask(payload, job.timeoutMs);
+        case "vocab":
+            return await executeVocabTask(job, payload);
         default:
             throw new Error(`Unknown task type: ${job.taskType}`);
     }
@@ -38,14 +41,12 @@ 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 = "";
+        // No internal timeout — the scheduler's withTaskTimeout() handles it
+        // using the per-job configurable timeoutMs (default 5min).
+        return await new Promise((resolve) => {
             sendToOrchestrator(`[Scheduled task] ${prompt}`, { type: "background" }, (text, done) => {
                 if (done) {
-                    clearTimeout(timeout);
-                    fullResponse = text;
-                    resolve(fullResponse);
+                    resolve(text);
                 }
             });
         });
@@ -106,7 +107,6 @@ async function executeBackupTask() {
             .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";
@@ -158,6 +158,124 @@ async function executeWebhookTask(payload, timeoutMs) {
         throw err;
     }
 }
+const VOCAB_PROMPT = `Generate a single advanced English vocabulary word for a Vietnamese learner. Pick an uncommon but useful word.
+
+You MUST respond in EXACTLY this format (no extra text, no markdown fences):
+
+WORD: <word>
+IPA: <IPA pronunciation>
+POS: <part of speech abbreviation: n., v., adj., adv., etc.>
+VI: <Vietnamese translation>
+EN_EXAMPLE: <example sentence in English using the word>
+VI_EXAMPLE: <Vietnamese translation of the example sentence>`;
+async function executeVocabTask(job, payload) {
+    const customPrompt = payload.prompt;
+    const prompt = customPrompt || VOCAB_PROMPT;
+    // Step 1: Get vocab from AI
+    let aiResponse;
+    try {
+        const { sendToOrchestrator } = await import("../copilot/orchestrator.js");
+        aiResponse = await new Promise((resolve) => {
+            sendToOrchestrator(`[Scheduled vocab task] ${prompt}`, { type: "background" }, (text, done) => {
+                if (done)
+                    resolve(text);
+            });
+        });
+    }
+    catch (err) {
+        throw new Error(`Vocab AI prompt failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Step 2: Parse the AI response
+    const parsed = parseVocabResponse(aiResponse);
+    // Step 3: Format the message
+    const formattedMessage = formatVocabMessage(parsed);
+    // Step 4: Send formatted text to Telegram
+    if (config.telegramEnabled) {
+        const { sendProactiveMessage } = await import("../telegram/bot.js");
+        await sendProactiveMessage(formattedMessage);
+    }
+    // Step 5: Generate TTS audio and send voice (macOS only)
+    if (config.telegramEnabled && parsed.word) {
+        try {
+            await generateAndSendVocabAudio(parsed.word);
+        }
+        catch (err) {
+            console.error("[nzb] Vocab TTS failed (non-fatal):", err instanceof Error ? err.message : err);
+        }
+    }
+    return formattedMessage;
+}
+function parseVocabResponse(response) {
+    const get = (key) => {
+        const regex = new RegExp(`^${key}:\\s*(.+)$`, "mi");
+        const match = response.match(regex);
+        return match?.[1]?.trim() ?? "";
+    };
+    return {
+        word: get("WORD"),
+        ipa: get("IPA"),
+        pos: get("POS"),
+        vi: get("VI"),
+        enExample: get("EN_EXAMPLE"),
+        viExample: get("VI_EXAMPLE"),
+    };
+}
+function formatVocabMessage(v) {
+    const lines = ["📖 WORD OF THE MINUTE", ""];
+    if (v.word) {
+        const ipaPart = v.ipa ? `  •  ${v.ipa}` : "";
+        lines.push(`✨ ${v.word}${ipaPart}`);
+    }
+    if (v.pos)
+        lines.push(`🏷 ${v.pos}`);
+    if (v.vi)
+        lines.push(`🇻🇳 ${v.vi}`);
+    lines.push("");
+    if (v.enExample)
+        lines.push(`💬 ${v.enExample}`);
+    if (v.viExample)
+        lines.push(`🔄 ${v.viExample}`);
+    return lines.join("\n");
+}
+async function generateAndSendVocabAudio(word) {
+    const aiffPath = "/tmp/vocab-word.aiff";
+    const m4aPath = "/tmp/vocab-word.m4a";
+    // Clean up previous files
+    try {
+        unlinkSync(aiffPath);
+    }
+    catch { /* ignore */ }
+    try {
+        unlinkSync(m4aPath);
+    }
+    catch { /* ignore */ }
+    // Generate TTS with macOS say
+    execSync(`say -v Samantha -o "${aiffPath}" "${word.replace(/"/g, '\\"')}"`, {
+        timeout: 10_000,
+    });
+    if (!existsSync(aiffPath)) {
+        throw new Error("TTS generation failed: aiff file not created");
+    }
+    // Convert to m4a
+    execSync(`afconvert -f mp4f -d aac "${aiffPath}" "${m4aPath}"`, {
+        timeout: 10_000,
+    });
+    if (!existsSync(m4aPath)) {
+        throw new Error("Audio conversion failed: m4a file not created");
+    }
+    // Send voice via Telegram
+    const { sendVoice } = await import("../telegram/bot.js");
+    await sendVoice(m4aPath, `🔊 ${word}`);
+    // Clean up temp files
+    try {
+        unlinkSync(aiffPath);
+    }
+    catch { /* ignore */ }
+    try {
+        unlinkSync(m4aPath);
+    }
+    catch { /* ignore */ }
+}
 function formatBytes(bytes) {
     if (bytes < 1024)
         return `${bytes}B`;

package/dist/daemon.js

@@ -8,7 +8,7 @@ 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";
+import { checkForUpdate, getDismissedVersion, isAutoUpdateEnabled, scheduleUpdateCheck, shouldCheckUpdate, stopUpdateCheck } from "./update.js";
 // Log the active CA bundle (injected by cli.ts via re-exec).
 if (process.env.NODE_EXTRA_CA_CERTS) {
     console.log(`[nzb] Using system CA bundle: ${process.env.NODE_EXTRA_CA_CERTS}`);
@@ -152,18 +152,60 @@ async function main() {
         console.log("[nzb] Telegram user ID missing — skipping bot. Run 'nzb setup' and enter your Telegram user ID (get it from @userinfobot).");
     }
     console.log("[nzb] NZB is fully operational.");
-    // Non-blocking update check — notify via console + all active channels
-    checkForUpdate()
-        .then(({ updateAvailable, current, latest }) => {
-        if (updateAvailable) {
-            const msg = `⬆ Update available: v${current} → v${latest} — run \`nzb update\` to install`;
-            console.log(`[nzb] ${msg}`);
-            if (config.telegramEnabled)
+    // Non-blocking update check — delayed 30s after startup, respects check interval
+    setTimeout(async () => {
+        try {
+            const autoEnabled = await isAutoUpdateEnabled();
+            if (!autoEnabled)
+                return;
+            const shouldCheck = await shouldCheckUpdate();
+            if (!shouldCheck)
+                return;
+            const result = await checkForUpdate();
+            if (result.updateAvailable && result.latest) {
+                const dismissed = await getDismissedVersion();
+                if (dismissed === result.latest)
+                    return;
+                const msg = `⬆ Update available: v${result.current} → v${result.latest} — run \`nzb update\` to install`;
+                console.log(`[nzb] ${msg}`);
+                if (config.telegramEnabled) {
+                    try {
+                        const { sendUpdateNotification } = await import("./telegram/handlers/update.js");
+                        const tgBot = (await import("./telegram/bot.js")).getBot();
+                        if (tgBot && config.authorizedUserId !== undefined) {
+                            await sendUpdateNotification(tgBot, config.authorizedUserId, result);
+                        }
+                    }
+                    catch {
+                        // Fallback to plain text
+                        sendProactiveMessage(msg).catch(() => { });
+                    }
+                }
+                broadcastToSSE(msg);
+            }
+        }
+        catch {
+            // Silent — network may be unavailable
+        }
+    }, 30_000);
+    // Schedule periodic update checks (every 6 hours)
+    scheduleUpdateCheck(async (result) => {
+        const msg = `⬆ Update available: v${result.current} → v${result.latest} — run \`nzb update\` to install`;
+        console.log(`[nzb] ${msg}`);
+        if (config.telegramEnabled) {
+            try {
+                const { sendUpdateNotification } = await import("./telegram/handlers/update.js");
+                const tgBot = (await import("./telegram/bot.js")).getBot();
+                if (tgBot && config.authorizedUserId !== undefined) {
+                    await sendUpdateNotification(tgBot, config.authorizedUserId, result);
+                }
+            }
+            catch {
                 sendProactiveMessage(msg).catch(() => { });
-            broadcastToSSE(msg);
+            }
         }
-    })
-        .catch(() => { }); // silent — network may be unavailable
+        broadcastToSSE(msg);
+    });
     // Notify user if this is a restart (not a fresh start)
     if (config.telegramEnabled && process.env.NZB_RESTARTED === "1") {
         await sendProactiveMessage("I'm back online.").catch(() => { });
@@ -198,6 +240,7 @@ async function shutdown() {
     // Stop health check timer first
     stopHealthCheck();
     stopCronScheduler();
+    stopUpdateCheck();
     if (config.telegramEnabled) {
         try {
             await stopBot();
@@ -225,6 +268,7 @@ export async function restartDaemon() {
     console.log("[nzb] Restarting...");
     stopHealthCheck();
     stopCronScheduler();
+    stopUpdateCheck();
     const activeWorkers = getWorkers();
     const runningCount = Array.from(activeWorkers.values()).filter((w) => w.status === "running").length;
     if (runningCount > 0) {

package/dist/telegram/bot.js

@@ -17,6 +17,7 @@ import { registerMediaHandlers } from "./handlers/media.js";
 import { registerReactionHandlers } from "./handlers/reactions.js";
 import { registerMessageHandler } from "./handlers/streaming.js";
 import { registerSmartSuggestionHandlers } from "./handlers/suggestions.js";
+import { registerUpdateHandlers } from "./handlers/update.js";
 import { initLogChannel, logError, logInfo } from "./log-channel.js";
 import { createMenus } from "./menus.js";
 let bot;
@@ -106,6 +107,7 @@ export function createBot() {
     // --- Handler registrations ---
     registerCallbackHandlers(bot);
     registerCronHandlers(bot);
+    registerUpdateHandlers(bot);
     registerInlineQueryHandler(bot);
     registerSmartSuggestionHandlers(bot);
     registerReactionHandlers(bot);
@@ -155,6 +157,7 @@ export async function startBot() {
             { command: "skills", description: "List installed skills" },
             { command: "memory", description: "Show stored memories" },
             { command: "cron", description: "Manage cron jobs" },
+            { command: "update", description: "Check for updates" },
             { command: "settings", description: "Bot settings" },
             { command: "restart", description: "Restart NZB" },
         ]);
@@ -315,4 +318,29 @@ export async function sendPhoto(photo, caption) {
         throw err;
     }
 }
+/** Send a voice/audio file to the authorized user (or a specific chat). Accepts a local file path. */
+export async function sendVoice(filePath, caption, chatId) {
+    if (!bot || config.authorizedUserId === undefined)
+        return;
+    const targetChat = chatId ?? config.authorizedUserId;
+    if (!isAllowedFilePath(filePath)) {
+        throw new Error("File path is not within allowed directories");
+    }
+    const { InputFile } = await import("grammy");
+    const input = new InputFile(filePath);
+    try {
+        // Use sendAudio for .m4a (shows as playable audio with duration),
+        // sendVoice for .ogg (shows as voice message bubble)
+        if (filePath.endsWith(".ogg")) {
+            await bot.api.sendVoice(targetChat, input, { caption });
+        }
+        else {
+            await bot.api.sendAudio(targetChat, input, { caption });
+        }
+    }
+    catch (err) {
+        console.error("[nzb] Failed to send voice:", err instanceof Error ? err.message : err);
+        throw err;
+    }
+}
 //# sourceMappingURL=bot.js.map

package/dist/telegram/handlers/commands.js

@@ -32,6 +32,7 @@ export function registerCommandHandlers(bot, deps) {
         "/skills — Installed skills\n" +
         "/workers — Active worker sessions\n" +
         "/cron — Manage cron jobs\n" +
+        "/update — Check for updates\n" +
         "/restart — Restart NZB\n\n" +
         "⚡ Breakthrough Features:\n" +
         "• @bot query — Use me inline in any chat!\n" +

package/dist/telegram/handlers/update.js

@@ -0,0 +1,211 @@
+import { InlineKeyboard } from "grammy";
+import { checkForUpdate, dismissVersion, getChangelog, getCurrentVersion, isAutoUpdateEnabled, performUpdate, toggleAutoUpdate, } from "../../update.js";
+/** Build the update menu inline keyboard. */
+async function buildUpdateKeyboard() {
+    const autoEnabled = await isAutoUpdateEnabled();
+    return new InlineKeyboard()
+        .text("🔍 Check Update", "update:check")
+        .text("⬆️ Update Now", "update:now")
+        .row()
+        .text("📋 Changelog", "update:changelog")
+        .text(`⚙️ Auto-Update: ${autoEnabled ? "ON" : "OFF"}`, "update:auto:toggle");
+}
+/** Build the notification keyboard shown when an update is available. */
+export function buildUpdateNotificationKeyboard() {
+    return new InlineKeyboard()
+        .text("⬆️ Update Now", "update:now")
+        .text("📋 Changelog", "update:changelog")
+        .row()
+        .text("❌ Dismiss", "update:dismiss");
+}
+/** Format an update check result for display. */
+function formatCheckResult(result) {
+    if (!result.checkSucceeded) {
+        return "❌ Could not reach npm registry. Check your network and try again.";
+    }
+    if (result.updateAvailable) {
+        const published = result.publishedAt
+            ? `\nPublished: ${new Date(result.publishedAt).toLocaleDateString()}`
+            : "";
+        return `🆕 Update available!\n\nCurrent: v${result.current}\nLatest: v${result.latest}${published}`;
+    }
+    return `✅ NZB v${result.current} is up to date.`;
+}
+/** Register the /update command and callback handlers. */
+export function registerUpdateHandlers(bot) {
+    // /update command — show update menu
+    bot.command("update", async (ctx) => {
+        const keyboard = await buildUpdateKeyboard();
+        const version = getCurrentVersion();
+        await ctx.reply(`📦 NZB Update Manager (v${version})`, { reply_markup: keyboard });
+    });
+    // Check for updates
+    bot.callbackQuery("update:check", async (ctx) => {
+        try {
+            await ctx.answerCallbackQuery({ text: "Checking for updates..." });
+            const result = await checkForUpdate();
+            const text = formatCheckResult(result);
+            if (result.updateAvailable) {
+                await ctx.editMessageText(text, { reply_markup: buildUpdateNotificationKeyboard() });
+            }
+            else {
+                const keyboard = await buildUpdateKeyboard();
+                await ctx.editMessageText(text, { reply_markup: keyboard });
+            }
+        }
+        catch (err) {
+            console.error("[nzb] Update check callback error:", err instanceof Error ? err.message : err);
+            await ctx.answerCallbackQuery({
+                text: `Error: ${err instanceof Error ? err.message : "Unknown error"}`,
+                show_alert: true,
+            }).catch(() => { });
+        }
+    });
+    // Update now — show confirmation dialog
+    bot.callbackQuery("update:now", async (ctx) => {
+        try {
+            await ctx.answerCallbackQuery();
+            const result = await checkForUpdate();
+            if (!result.checkSucceeded) {
+                await ctx.editMessageText("❌ Cannot reach npm registry. Try again later.");
+                return;
+            }
+            if (!result.updateAvailable) {
+                const keyboard = await buildUpdateKeyboard();
+                await ctx.editMessageText(`✅ NZB v${result.current} is already the latest version.`, {
+                    reply_markup: keyboard,
+                });
+                return;
+            }
+            const confirmKeyboard = new InlineKeyboard()
+                .text("✅ Yes, update now", "update:confirm")
+                .text("❌ Cancel", "update:cancel");
+            await ctx.editMessageText(`⚠️ Update NZB?\n\nv${result.current} → v${result.latest}\n\nThis will install the new version and restart the daemon.`, { reply_markup: confirmKeyboard });
+        }
+        catch (err) {
+            console.error("[nzb] Update now callback error:", err instanceof Error ? err.message : err);
+            await ctx.answerCallbackQuery({
+                text: `Error: ${err instanceof Error ? err.message : "Unknown error"}`,
+                show_alert: true,
+            }).catch(() => { });
+        }
+    });
+    // Confirm update — actually perform the update
+    bot.callbackQuery("update:confirm", async (ctx) => {
+        try {
+            await ctx.answerCallbackQuery({ text: "Updating..." });
+            await ctx.editMessageText("⏳ Installing update... This may take a minute.");
+            const result = await performUpdate();
+            if (!result.ok) {
+                const keyboard = await buildUpdateKeyboard();
+                await ctx.editMessageText(`❌ Update failed:\n${result.output}`, { reply_markup: keyboard });
+                return;
+            }
+            await ctx.editMessageText("✅ Update installed! Restarting NZB...");
+            // Restart daemon after a short delay
+            setTimeout(async () => {
+                try {
+                    const { restartDaemon } = await import("../../daemon.js");
+                    await restartDaemon();
+                }
+                catch (err) {
+                    console.error("[nzb] Post-update restart failed:", err);
+                }
+            }, 1000);
+        }
+        catch (err) {
+            console.error("[nzb] Update confirm callback error:", err instanceof Error ? err.message : err);
+            await ctx.answerCallbackQuery({
+                text: `Error: ${err instanceof Error ? err.message : "Unknown error"}`,
+                show_alert: true,
+            }).catch(() => { });
+        }
+    });
+    // Cancel update
+    bot.callbackQuery("update:cancel", async (ctx) => {
+        try {
+            await ctx.answerCallbackQuery({ text: "Cancelled" });
+            const keyboard = await buildUpdateKeyboard();
+            const version = getCurrentVersion();
+            await ctx.editMessageText(`📦 NZB Update Manager (v${version})`, { reply_markup: keyboard });
+        }
+        catch (err) {
+            console.error("[nzb] Update cancel callback error:", err instanceof Error ? err.message : err);
+            await ctx.answerCallbackQuery({
+                text: `Error: ${err instanceof Error ? err.message : "Unknown error"}`,
+                show_alert: true,
+            }).catch(() => { });
+        }
+    });
+    // Show changelog
+    bot.callbackQuery("update:changelog", async (ctx) => {
+        try {
+            await ctx.answerCallbackQuery({ text: "Fetching changelog..." });
+            const entries = await getChangelog(8);
+            if (entries.length === 0) {
+                await ctx.editMessageText("📋 Could not fetch version history.", {
+                    reply_markup: await buildUpdateKeyboard(),
+                });
+                return;
+            }
+            const current = getCurrentVersion();
+            const lines = entries.map((e) => {
+                const marker = e.version === current ? " ← current" : "";
+                return `• v${e.version} (${e.date})${marker}`;
+            });
+            const keyboard = await buildUpdateKeyboard();
+            await ctx.editMessageText(`📋 Recent versions:\n\n${lines.join("\n")}`, { reply_markup: keyboard });
+        }
+        catch (err) {
+            console.error("[nzb] Changelog callback error:", err instanceof Error ? err.message : err);
+            await ctx.answerCallbackQuery({
+                text: `Error: ${err instanceof Error ? err.message : "Unknown error"}`,
+                show_alert: true,
+            }).catch(() => { });
+        }
+    });
+    // Toggle auto-update
+    bot.callbackQuery("update:auto:toggle", async (ctx) => {
+        try {
+            const newState = await toggleAutoUpdate();
+            await ctx.answerCallbackQuery({ text: `Auto-Update ${newState ? "ON" : "OFF"}` });
+            const keyboard = await buildUpdateKeyboard();
+            const version = getCurrentVersion();
+            await ctx.editMessageText(`📦 NZB Update Manager (v${version})`, { reply_markup: keyboard });
+        }
+        catch (err) {
+            console.error("[nzb] Auto-update toggle error:", err instanceof Error ? err.message : err);
+            await ctx.answerCallbackQuery({
+                text: `Error: ${err instanceof Error ? err.message : "Unknown error"}`,
+                show_alert: true,
+            }).catch(() => { });
+        }
+    });
+    // Dismiss update notification
+    bot.callbackQuery("update:dismiss", async (ctx) => {
+        try {
+            const result = await checkForUpdate();
+            if (result.latest) {
+                await dismissVersion(result.latest);
+            }
+            await ctx.answerCallbackQuery({ text: "Dismissed" });
+            await ctx.editMessageText(`📦 NZB v${result.current} — update notification dismissed.`);
+        }
+        catch (err) {
+            console.error("[nzb] Dismiss callback error:", err instanceof Error ? err.message : err);
+            await ctx.answerCallbackQuery({
+                text: `Error: ${err instanceof Error ? err.message : "Unknown error"}`,
+                show_alert: true,
+            }).catch(() => { });
+        }
+    });
+}
+/** Send a proactive update notification to a chat. */
+export async function sendUpdateNotification(bot, chatId, result) {
+    const keyboard = buildUpdateNotificationKeyboard();
+    const published = result.publishedAt
+        ? ` (${new Date(result.publishedAt).toLocaleDateString()})`
+        : "";
+    await bot.api.sendMessage(chatId, `🆕 NZB v${result.latest} available!${published}\nCurrent: v${result.current}\n\nRun \`nzb update\` or use the buttons below.`, { reply_markup: keyboard, parse_mode: "Markdown" });
+}
+//# sourceMappingURL=update.js.map

package/dist/telegram/menus.js

@@ -239,6 +239,20 @@ export function createMenus(getUptimeStr) {
     });
     // Main interactive menu with navigation
     const mainMenu = new Menu("main-menu")
+        .text("⏰ Cron", async (ctx) => {
+        try {
+            await ctx.answerCallbackQuery();
+            const { sendCronMenu } = await import("./handlers/cron.js");
+            await sendCronMenu(ctx);
+        }
+        catch (err) {
+            console.error("[nzb] Menu callback error:", err instanceof Error ? err.message : err);
+            await ctx.answerCallbackQuery({
+                text: `Error: ${err instanceof Error ? err.message : "Unknown error"}`,
+                show_alert: true,
+            }).catch(() => { });
+        }
+    })
         .text("📊 Status", async (ctx) => {
         try {
             const workers = Array.from(getWorkers().values());

package/dist/update.js

@@ -4,6 +4,9 @@ import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PKG_NAME = "@iletai/nzb";
+const NPM_REGISTRY_URL = `https://registry.npmjs.org/${PKG_NAME}`;
+const CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+let updateCheckTimer;
 function getPackageJson() {
     try {
         const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
@@ -54,11 +57,37 @@ function isNewer(local, remote) {
 export async function checkForUpdate() {
     const current = getLocalVersion();
     const latest = await getLatestVersion();
+    let publishedAt;
+    // Try to fetch publish date from registry
+    if (latest) {
+        try {
+            const res = await fetch(`${NPM_REGISTRY_URL}/latest`, { signal: AbortSignal.timeout(10_000) });
+            if (res.ok) {
+                const data = (await res.json());
+                const time = data.time;
+                if (time && latest in time) {
+                    publishedAt = time[latest];
+                }
+            }
+        }
+        catch {
+            // Expected: registry may be unreachable
+        }
+    }
+    // Record the check timestamp
+    try {
+        const { setState } = await import("./store/db.js");
+        setState("last_update_check", new Date().toISOString());
+    }
+    catch {
+        // Expected: DB may not be initialized during CLI usage
+    }
     return {
         current,
         latest,
         updateAvailable: latest !== null && isNewer(current, latest),
         checkSucceeded: latest !== null,
+        publishedAt,
     };
 }
 /** Run `npm install -g <pkg>@latest` and return success/failure. */
@@ -67,7 +96,23 @@ export async function performUpdate() {
         const { name } = getPackageJson();
         const output = execSync(`npm install -g ${name}@latest`, {
             encoding: "utf-8",
-            timeout: 60_000,
+            timeout: 120_000,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return { ok: true, output: output.trim() };
+    }
+    catch (err) {
+        const msg = err.stderr?.trim() || err.message || "Unknown error";
+        return { ok: false, output: msg };
+    }
+}
+/** Force update even if the same version is installed. */
+export async function performForceUpdate() {
+    try {
+        const { name } = getPackageJson();
+        const output = execSync(`npm install -g ${name}@latest --force`, {
+            encoding: "utf-8",
+            timeout: 120_000,
             stdio: ["ignore", "pipe", "pipe"],
         });
         return { ok: true, output: output.trim() };
@@ -77,4 +122,128 @@ export async function performUpdate() {
         return { ok: false, output: msg };
     }
 }
+/**
+ * Check if enough time has passed since the last update check.
+ * Returns true if we should check now (>= 6 hours since last check).
+ */
+export async function shouldCheckUpdate() {
+    try {
+        const { getState } = await import("./store/db.js");
+        const last = getState("last_update_check");
+        if (!last)
+            return true;
+        const elapsed = Date.now() - new Date(last).getTime();
+        return elapsed >= CHECK_INTERVAL_MS;
+    }
+    catch {
+        // DB not ready — check anyway
+        return true;
+    }
+}
+/**
+ * Check if auto-update notifications are enabled.
+ * Defaults to true if not explicitly set.
+ */
+export async function isAutoUpdateEnabled() {
+    try {
+        const { getState } = await import("./store/db.js");
+        const val = getState("auto_update_enabled");
+        return val !== "false";
+    }
+    catch {
+        return true;
+    }
+}
+/** Toggle auto-update notifications on/off. Returns the new state. */
+export async function toggleAutoUpdate() {
+    const { getState, setState } = await import("./store/db.js");
+    const current = getState("auto_update_enabled");
+    const newVal = current === "false" ? "true" : "false";
+    setState("auto_update_enabled", newVal);
+    return newVal === "true";
+}
+/**
+ * Get the version that the user dismissed (won't be notified about again).
+ */
+export async function getDismissedVersion() {
+    try {
+        const { getState } = await import("./store/db.js");
+        return getState("dismissed_version");
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Dismiss update notifications for a specific version. */
+export async function dismissVersion(version) {
+    const { setState } = await import("./store/db.js");
+    setState("dismissed_version", version);
+}
+/**
+ * Fetch recent version history from npm registry for changelog display.
+ * Returns the last N versions with their publish dates.
+ */
+export async function getChangelog(limit = 5) {
+    try {
+        const res = await fetch(NPM_REGISTRY_URL, { signal: AbortSignal.timeout(15_000) });
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        if (!data.time || !data.versions)
+            return [];
+        const versions = Object.keys(data.versions)
+            .filter((v) => v in data.time && v !== "created" && v !== "modified")
+            .sort((a, b) => {
+            const dateA = new Date(data.time[a]).getTime();
+            const dateB = new Date(data.time[b]).getTime();
+            return dateB - dateA;
+        })
+            .slice(0, limit);
+        return versions.map((v) => ({
+            version: v,
+            date: new Date(data.time[v]).toISOString().split("T")[0],
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/** Get the current local version. */
+export function getCurrentVersion() {
+    return getLocalVersion();
+}
+/**
+ * Schedule periodic update checks (every 6 hours).
+ * Calls the provided callback when an update is found.
+ */
+export function scheduleUpdateCheck(onUpdateFound) {
+    if (updateCheckTimer)
+        return; // already scheduled
+    updateCheckTimer = setInterval(async () => {
+        try {
+            const autoEnabled = await isAutoUpdateEnabled();
+            if (!autoEnabled)
+                return;
+            const result = await checkForUpdate();
+            if (result.updateAvailable && result.latest) {
+                const dismissed = await getDismissedVersion();
+                if (dismissed === result.latest)
+                    return;
+                onUpdateFound(result);
+            }
+        }
+        catch {
+            // Silent — network may be unavailable
+        }
+    }, CHECK_INTERVAL_MS);
+    updateCheckTimer.unref();
+    console.log("[nzb] Update check scheduled (every 6 hours)");
+}
+/** Stop the periodic update check timer. */
+export function stopUpdateCheck() {
+    if (updateCheckTimer) {
+        clearInterval(updateCheckTimer);
+        updateCheckTimer = undefined;
+    }
+}
 //# sourceMappingURL=update.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@iletai/nzb",
-    "version": "1.8.0",
+    "version": "1.8.2",
     "description": "NZB — a personal AI assistant for developers, built on the GitHub Copilot SDK",
     "bin": {
         "nzb": "dist/cli.js"