@iletai/nzb 1.8.0 → 1.8.1

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/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" },
         ]);

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/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.1",
     "description": "NZB — a personal AI assistant for developers, built on the GitHub Copilot SDK",
     "bin": {
         "nzb": "dist/cli.js"