@iletai/nzb 1.7.4 → 1.8.1

package/dist/cli.js

@@ -45,6 +45,9 @@ 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
 
 Flags (start):
@@ -76,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}`);
@@ -98,6 +128,101 @@ switch (command) {
         }
         break;
     }
+    case "cron": {
+        const subcommand = args[1] || "list";
+        const { listCronJobs, createCronJob, deleteCronJob, updateCronJob } = await import("./store/cron-store.js");
+        switch (subcommand) {
+            case "list": {
+                const jobs = listCronJobs();
+                if (jobs.length === 0) {
+                    console.log("No cron jobs configured.");
+                }
+                else {
+                    for (const job of jobs) {
+                        const status = job.enabled ? "✅" : "⏸️";
+                        console.log(`${status} ${job.id} — ${job.name} [${job.taskType}] ${job.cronExpression}`);
+                    }
+                }
+                break;
+            }
+            case "add": {
+                const id = args[2];
+                const name = args[3];
+                const cronExpr = args[4];
+                const taskType = args[5];
+                if (!id || !name || !cronExpr || !taskType) {
+                    console.error("Usage: nzb cron add <id> <name> <cron-expression> <task-type> [payload-json]");
+                    console.error("Task types: prompt, health_check, backup, notification, webhook");
+                    process.exit(1);
+                }
+                const validTypes = ["prompt", "health_check", "backup", "notification", "webhook"];
+                if (!validTypes.includes(taskType)) {
+                    console.error(`Invalid task type: ${taskType}. Valid: ${validTypes.join(", ")}`);
+                    process.exit(1);
+                }
+                const { Cron } = await import("croner");
+                try {
+                    new Cron(cronExpr);
+                }
+                catch {
+                    console.error(`Invalid cron expression: ${cronExpr}`);
+                    process.exit(1);
+                }
+                const payload = args[6] || "{}";
+                try {
+                    const job = createCronJob({
+                        id,
+                        name,
+                        cronExpression: cronExpr,
+                        taskType: taskType,
+                        payload,
+                    });
+                    console.log(`Created cron job '${job.id}' (${job.name}): ${job.cronExpression}`);
+                    console.log("Note: The job will be scheduled when the daemon starts.");
+                }
+                catch (err) {
+                    console.error("Error:", err instanceof Error ? err.message : err);
+                    process.exit(1);
+                }
+                break;
+            }
+            case "remove": {
+                const removeId = args[2];
+                if (!removeId) {
+                    console.error("Usage: nzb cron remove <id>");
+                    process.exit(1);
+                }
+                const deleted = deleteCronJob(removeId);
+                console.log(deleted ? `Deleted cron job '${removeId}'.` : `Job '${removeId}' not found.`);
+                break;
+            }
+            case "enable": {
+                const enableId = args[2];
+                if (!enableId) {
+                    console.error("Usage: nzb cron enable <id>");
+                    process.exit(1);
+                }
+                const enabled = updateCronJob(enableId, { enabled: true });
+                console.log(enabled ? `Enabled cron job '${enableId}'.` : `Job '${enableId}' not found.`);
+                break;
+            }
+            case "disable": {
+                const disableId = args[2];
+                if (!disableId) {
+                    console.error("Usage: nzb cron disable <id>");
+                    process.exit(1);
+                }
+                const disabled = updateCronJob(disableId, { enabled: false });
+                console.log(disabled ? `Disabled cron job '${disableId}'.` : `Job '${disableId}' not found.`);
+                break;
+            }
+            default:
+                console.error(`Unknown cron subcommand: ${subcommand}`);
+                console.error("Available: list, add, remove, enable, disable");
+                process.exit(1);
+        }
+        break;
+    }
     case "help":
     case "--help":
     case "-h":

package/dist/config.js

@@ -82,6 +82,10 @@ export const config = {
     groupMentionOnly: process.env.GROUP_MENTION_ONLY !== "false",
     /** Reasoning effort: low | medium | high */
     reasoningEffort: validateEnum(process.env.REASONING_EFFORT, ["low", "medium", "high"], "medium", "REASONING_EFFORT"),
+    /** Model failover chain: comma-separated list of fallback models */
+    modelFailoverChain: process.env.MODEL_FAILOVER_CHAIN?.split(",").map((s) => s.trim()).filter(Boolean) ?? [],
+    /** Cooldown duration (ms) for a model after failure before retrying it */
+    modelCooldownMs: parseInt(process.env.MODEL_COOLDOWN_MS ?? "60000"),
 };
 /** Persist an env variable to ~/.nzb/.env */
 export function persistEnvVar(key, value) {

package/dist/copilot/model-failover.js

@@ -0,0 +1,154 @@
+/**
+ * Model Failover Manager — tracks model health and selects fallback models
+ * when the primary model encounters errors (rate limits, timeouts, etc.).
+ *
+ * When MODEL_FAILOVER_CHAIN is empty, this module is a no-op:
+ * selectModel() returns the configured primary, and getNextFallback() returns undefined.
+ */
+/** Detect the provider from a model name string. */
+export function detectProvider(model) {
+    const lower = model.toLowerCase();
+    if (lower.startsWith("claude-"))
+        return "anthropic";
+    if (lower.startsWith("gpt-") || lower.startsWith("o1-") || lower.startsWith("o3-") || lower.startsWith("o4-"))
+        return "openai";
+    if (lower.startsWith("gemini-"))
+        return "google";
+    return "unknown";
+}
+/** Number of consecutive failures before a model is considered "degraded". */
+const DEGRADED_THRESHOLD = 3;
+export class ModelFailoverManager {
+    chain;
+    cooldownMs;
+    health = new Map();
+    constructor(chain, cooldownMs) {
+        this.chain = Array.isArray(chain) ? chain : [];
+        this.cooldownMs = cooldownMs || 60_000;
+        // Initialise health entries for every model in the chain
+        for (const model of this.chain) {
+            this.health.set(model, {
+                failures: 0,
+                lastFailure: undefined,
+                cooldownUntil: 0,
+                successCount: 0,
+            });
+        }
+    }
+    /** True when at least one fallback model is configured. */
+    get enabled() {
+        return this.chain.length > 0;
+    }
+    /**
+     * Select the best model to use right now.
+     * Returns the first healthy model from the chain, or undefined when the
+     * chain is empty (caller should fall back to `config.copilotModel`).
+     */
+    selectModel() {
+        if (this.chain.length === 0)
+            return undefined;
+        const now = Date.now();
+        for (const model of this.chain) {
+            const h = this.getOrCreate(model);
+            if (now >= h.cooldownUntil)
+                return model;
+        }
+        // All models are on cooldown — pick the one whose cooldown expires soonest
+        let earliest;
+        let earliestTime = Infinity;
+        for (const model of this.chain) {
+            const h = this.getOrCreate(model);
+            if (h.cooldownUntil < earliestTime) {
+                earliestTime = h.cooldownUntil;
+                earliest = model;
+            }
+        }
+        return earliest;
+    }
+    /** Record a successful request for `model`. Resets its failure counter. */
+    recordSuccess(model) {
+        const h = this.getOrCreate(model);
+        h.failures = 0;
+        h.cooldownUntil = 0;
+        h.successCount++;
+    }
+    /** Record a failed request for `model`. Applies cooldown after threshold. */
+    recordFailure(model) {
+        const h = this.getOrCreate(model);
+        h.failures++;
+        h.lastFailure = Date.now();
+        // Apply cooldown immediately on failure so we try a different model next
+        h.cooldownUntil = Date.now() + this.cooldownMs;
+    }
+    /**
+     * Get the next fallback model after `currentModel`.
+     * Prefers a model from a DIFFERENT provider to maximise availability.
+     */
+    getNextFallback(currentModel) {
+        if (this.chain.length === 0)
+            return undefined;
+        const now = Date.now();
+        const currentProvider = detectProvider(currentModel);
+        // First pass: healthy model from a different provider
+        for (const model of this.chain) {
+            if (model === currentModel)
+                continue;
+            const h = this.getOrCreate(model);
+            if (now >= h.cooldownUntil && detectProvider(model) !== currentProvider) {
+                return model;
+            }
+        }
+        // Second pass: any healthy model (same provider is OK)
+        for (const model of this.chain) {
+            if (model === currentModel)
+                continue;
+            const h = this.getOrCreate(model);
+            if (now >= h.cooldownUntil) {
+                return model;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Detect whether an error is a model-level error that warrants failover
+     * (as opposed to a generic connectivity issue that warrants simple retry).
+     */
+    isModelError(err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return /429|rate.?limit|too many requests|quota|capacity|overloaded|model.*not.*available|model.*error|resource.*exhausted/i.test(msg);
+    }
+    /** Return a snapshot of health status for every model in the chain. */
+    getHealthStatus() {
+        return this.chain.map((model) => {
+            const h = this.getOrCreate(model);
+            const now = Date.now();
+            let status;
+            if (h.failures >= DEGRADED_THRESHOLD) {
+                status = "degraded";
+            }
+            else if (now < h.cooldownUntil) {
+                status = "cooldown";
+            }
+            else {
+                status = "healthy";
+            }
+            return {
+                model,
+                provider: detectProvider(model),
+                status,
+                failures: h.failures,
+                successCount: h.successCount,
+                lastFailure: h.lastFailure ? new Date(h.lastFailure).toISOString() : undefined,
+            };
+        });
+    }
+    getOrCreate(model) {
+        let h = this.health.get(model);
+        if (!h) {
+            h = { failures: 0, lastFailure: undefined, cooldownUntil: 0, successCount: 0 };
+            this.health.set(model, h);
+        }
+        return h;
+    }
+}
+//# sourceMappingURL=model-failover.js.map

package/dist/copilot/orchestrator.js

@@ -8,6 +8,7 @@ import { completeTeam, updateTeamMemberResult } from "../store/team-store.js";
 import { formatAge, withTimeout } from "../utils.js";
 import { resetClient } from "./client.js";
 import { loadMcpConfig } from "./mcp-config.js";
+import { ModelFailoverManager } from "./model-failover.js";
 import { getSkillDirectories } from "./skills.js";
 import { getOrchestratorSystemMessage } from "./system-message.js";
 import { createTools } from "./tools.js";
@@ -32,6 +33,8 @@ const workers = new Map();
 const teams = new Map();
 let healthCheckTimer;
 let workerReaperTimer;
+// Model failover manager — initialised lazily in initOrchestrator
+let failoverManager;
 // Persistent orchestrator session
 let orchestratorSession;
 // Coalesces concurrent ensureOrchestratorSession calls
@@ -336,6 +339,11 @@ async function createOrResumeSession() {
 export async function initOrchestrator(client) {
     copilotClient = client;
     const { mcpServers, skillDirectories } = getSessionConfig();
+    // Initialise failover manager from config
+    failoverManager = new ModelFailoverManager(config.modelFailoverChain, config.modelCooldownMs);
+    if (failoverManager.enabled) {
+        console.log(`[nzb] Model failover chain: ${config.modelFailoverChain.join(" → ")}`);
+    }
     // Validate configured model against available models (skip for default — saves 1-3s startup)
     if (config.copilotModel !== DEFAULT_MODEL) {
         try {
@@ -605,6 +613,10 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent,
                         processQueue();
                     });
                     // Deliver response to user FIRST, then log best-effort
+                    // Record success for failover tracking
+                    if (failoverManager?.enabled) {
+                        failoverManager.recordSuccess(config.copilotModel);
+                    }
                     try {
                         logMessage("out", sourceLabel, finalContent);
                     }
@@ -669,6 +681,20 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent,
                         continue;
                     }
                     if (isRecoverableError(err) && attempt < MAX_RETRIES) {
+                        // Model failover: if it's a model-level error and we have fallbacks, switch model
+                        if (failoverManager?.enabled && failoverManager.isModelError(err)) {
+                            const failedModel = config.copilotModel;
+                            failoverManager.recordFailure(failedModel);
+                            const fallback = failoverManager.getNextFallback(failedModel);
+                            if (fallback) {
+                                console.log(`[nzb] Model failover: ${failedModel} → ${fallback} (${msg})`);
+                                config.copilotModel = fallback;
+                                // Force session recreation with the new model
+                                orchestratorSession = undefined;
+                                sessionCreatedAt = undefined;
+                                deleteState(ORCHESTRATOR_SESSION_KEY);
+                            }
+                        }
                         const delay = RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)];
                         console.error(`[nzb] Recoverable error: ${msg}. Retry ${attempt + 1}/${MAX_RETRIES} after ${delay}ms…`);
                         await sleep(delay);
@@ -681,6 +707,27 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent,
                         }
                         continue;
                     }
+                    // Model-level error with failover available — try switching model even if not normally recoverable
+                    if (failoverManager?.enabled && failoverManager.isModelError(err) && attempt < MAX_RETRIES) {
+                        const failedModel = config.copilotModel;
+                        failoverManager.recordFailure(failedModel);
+                        const fallback = failoverManager.getNextFallback(failedModel);
+                        if (fallback) {
+                            console.log(`[nzb] Model failover: ${failedModel} → ${fallback} (${msg})`);
+                            config.copilotModel = fallback;
+                            orchestratorSession = undefined;
+                            sessionCreatedAt = undefined;
+                            deleteState(ORCHESTRATOR_SESSION_KEY);
+                            await sleep(RECONNECT_DELAYS_MS[0]);
+                            try {
+                                await ensureClient();
+                            }
+                            catch {
+                                /* will fail again on next attempt */
+                            }
+                            continue;
+                        }
+                    }
                     console.error(`[nzb] Error processing message: ${msg}`);
                     if (!globalTimedOut) {
                         await callback(`Error: ${msg}`, true);
@@ -767,4 +814,8 @@ export async function compactSession() {
         return `Compaction failed: ${err instanceof Error ? err.message : String(err)}`;
     }
 }
+/** Expose the failover manager so tools can query health status. */
+export function getFailoverManager() {
+    return failoverManager;
+}
 //# sourceMappingURL=orchestrator.js.map

package/dist/copilot/tools.js

@@ -4,10 +4,13 @@ import { homedir } from "os";
 import { join, resolve, sep } from "path";
 import { z } from "zod";
 import { config, persistModel } from "../config.js";
+import { scheduleJob, triggerJob, unscheduleJob, getSchedulerStatus } from "../cron/scheduler.js";
 import { SESSIONS_DIR } from "../paths.js";
 import { getDb } from "../store/db.js";
+import { createCronJob, deleteCronJob, getCronJob, getRecentRuns, updateCronJob, } from "../store/cron-store.js";
 import { withTimeout } from "../utils.js";
 import { addMemory, removeMemory, searchMemories } from "../store/memory.js";
+import { getFailoverManager } from "./orchestrator.js";
 import { createSkill, listSkills, removeSkill } from "./skills.js";
 function isTimeoutError(err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -652,6 +655,27 @@ export function createTools(deps) {
                 }
             },
         }),
+        defineTool("model_health", {
+            description: "Show health status of all models in the failover chain. " +
+                "Displays model name, provider, status (healthy/cooldown/degraded), failure count, and last failure time. " +
+                "Use when the user asks about model health, failover status, or which models are available in the chain.",
+            parameters: z.object({}),
+            handler: async () => {
+                const manager = getFailoverManager();
+                if (!manager || !manager.enabled) {
+                    return (`Model failover is not configured. Current model: ${config.copilotModel}\n\n` +
+                        `To enable failover, set MODEL_FAILOVER_CHAIN in ~/.nzb/.env with a comma-separated list of models.\n` +
+                        `Example: MODEL_FAILOVER_CHAIN=claude-sonnet-4.6,gpt-4.1,gemini-2.0-flash`);
+                }
+                const statuses = manager.getHealthStatus();
+                const lines = statuses.map((s) => {
+                    const icon = s.status === "healthy" ? "✅" : s.status === "cooldown" ? "⏳" : "⚠️";
+                    const lastFail = s.lastFailure ? ` (last fail: ${s.lastFailure})` : "";
+                    return `${icon} ${s.model} [${s.provider}] — ${s.status} | failures: ${s.failures} | successes: ${s.successCount}${lastFail}`;
+                });
+                return `Model Failover Health (active: ${config.copilotModel}):\n${lines.join("\n")}`;
+            },
+        }),
         defineTool("remember", {
             description: "Save something to NZB's long-term memory. Use when the user says 'remember that...', " +
                 "states a preference, shares a fact about themselves, or mentions something important " +
@@ -706,6 +730,111 @@ export function createTools(deps) {
                     : `Memory #${args.memory_id} not found — it may have already been removed.`;
             },
         }),
+        defineTool("manage_cron", {
+            description: "Manage scheduled cron jobs. Use to create, list, remove, enable, disable, or trigger " +
+                "recurring tasks like health checks, backups, notifications, webhook calls, or scheduled prompts.",
+            parameters: z.object({
+                action: z
+                    .enum(["list", "add", "remove", "enable", "disable", "trigger", "history"])
+                    .describe("Action to perform"),
+                job_id: z.string().optional().describe("Job ID (required for remove/enable/disable/trigger/history)"),
+                name: z.string().optional().describe("Job name (required for add)"),
+                cron_expression: z
+                    .string()
+                    .optional()
+                    .describe("Cron expression, e.g. '0 */6 * * *' for every 6 hours (required for add)"),
+                task_type: z
+                    .enum(["prompt", "health_check", "backup", "notification", "webhook"])
+                    .optional()
+                    .describe("Task type (required for add)"),
+                payload: z.string().optional().describe("JSON payload for the task (optional for add)"),
+                notify_telegram: z.boolean().optional().describe("Send result to Telegram (default: true)"),
+            }),
+            handler: async (args) => {
+                try {
+                    switch (args.action) {
+                        case "list": {
+                            const status = getSchedulerStatus();
+                            if (status.length === 0)
+                                return "No cron jobs configured.";
+                            const lines = status.map((j) => `• ${j.id} — ${j.name} [${j.taskType}] ${j.enabled ? "✅" : "⏸️"} ` +
+                                `${j.active ? "active" : "inactive"} | ${j.cronExpression}` +
+                                (j.nextRun ? ` | next: ${j.nextRun}` : ""));
+                            return `${status.length} cron job(s):\n${lines.join("\n")}`;
+                        }
+                        case "add": {
+                            if (!args.job_id || !args.name || !args.cron_expression || !args.task_type) {
+                                return "Missing required fields: job_id, name, cron_expression, task_type";
+                            }
+                            const job = createCronJob({
+                                id: args.job_id,
+                                name: args.name,
+                                cronExpression: args.cron_expression,
+                                taskType: args.task_type,
+                                payload: args.payload,
+                                notifyTelegram: args.notify_telegram,
+                            });
+                            if (job.enabled)
+                                scheduleJob(job);
+                            return `Cron job '${job.id}' (${job.name}) created and scheduled: ${job.cronExpression}`;
+                        }
+                        case "remove": {
+                            if (!args.job_id)
+                                return "Missing job_id";
+                            unscheduleJob(args.job_id);
+                            const deleted = deleteCronJob(args.job_id);
+                            return deleted
+                                ? `Cron job '${args.job_id}' deleted.`
+                                : `Job '${args.job_id}' not found.`;
+                        }
+                        case "enable": {
+                            if (!args.job_id)
+                                return "Missing job_id";
+                            const enabled = updateCronJob(args.job_id, { enabled: true });
+                            if (!enabled)
+                                return `Job '${args.job_id}' not found.`;
+                            scheduleJob(enabled);
+                            return `Cron job '${args.job_id}' enabled and scheduled.`;
+                        }
+                        case "disable": {
+                            if (!args.job_id)
+                                return "Missing job_id";
+                            const disabled = updateCronJob(args.job_id, { enabled: false });
+                            if (!disabled)
+                                return `Job '${args.job_id}' not found.`;
+                            unscheduleJob(args.job_id);
+                            return `Cron job '${args.job_id}' disabled.`;
+                        }
+                        case "trigger": {
+                            if (!args.job_id)
+                                return "Missing job_id";
+                            const result = await triggerJob(args.job_id);
+                            return `Triggered '${args.job_id}':\n${result}`;
+                        }
+                        case "history": {
+                            if (!args.job_id)
+                                return "Missing job_id";
+                            const job = getCronJob(args.job_id);
+                            if (!job)
+                                return `Job '${args.job_id}' not found.`;
+                            const runs = getRecentRuns(args.job_id);
+                            if (runs.length === 0)
+                                return `No runs recorded for '${args.job_id}'.`;
+                            const lines = runs.map((r) => `• ${r.status} at ${r.startedAt}` +
+                                (r.durationMs !== null ? ` (${r.durationMs}ms)` : "") +
+                                (r.error ? ` — ${r.error}` : "") +
+                                (r.result ? ` — ${r.result.slice(0, 100)}` : ""));
+                            return `Recent runs for '${job.name}':\n${lines.join("\n")}`;
+                        }
+                        default:
+                            return `Unknown action: ${args.action}`;
+                    }
+                }
+                catch (err) {
+                    return `Cron error: ${err instanceof Error ? err.message : String(err)}`;
+                }
+            },
+        }),
         defineTool("restart_nzb", {
             description: "Restart the NZB daemon process. Use when the user asks NZB to restart himself, " +
                 "or when a restart is needed to pick up configuration changes. " +
@@ -726,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) {