@iletai/nzb 1.7.3 → 1.7.4

package/dist/api/server.js

@@ -77,8 +77,23 @@ app.get("/stream", (req, res) => {
     sseClients.set(connectionId, res);
     // Heartbeat to keep connection alive
     const heartbeat = setInterval(() => {
-        res.write(`:ping\n\n`);
+        if (res.writableEnded || res.closed) {
+            clearInterval(heartbeat);
+            sseClients.delete(connectionId);
+            return;
+        }
+        try {
+            res.write(`:ping\n\n`);
+        }
+        catch {
+            clearInterval(heartbeat);
+            sseClients.delete(connectionId);
+        }
     }, 20_000);
+    res.on("error", () => {
+        clearInterval(heartbeat);
+        sseClients.delete(connectionId);
+    });
     req.on("close", () => {
         clearInterval(heartbeat);
         sseClients.delete(connectionId);
@@ -196,6 +211,13 @@ app.post("/send-photo", async (req, res) => {
         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);
+    if (!res.headersSent) {
+        res.status(500).json({ error: "Internal server error" });
+    }
+});
 export function startApiServer() {
     return new Promise((resolve, reject) => {
         const server = app.listen(config.apiPort, "127.0.0.1", () => {

package/dist/copilot/orchestrator.js

@@ -155,6 +155,8 @@ function startHealthCheck() {
             return;
         if (healthCheckRunning)
             return;
+        if (processing)
+            return; // Don't interfere while processing messages
         healthCheckRunning = true;
         try {
             const state = copilotClient.getState();
@@ -188,17 +190,17 @@ export function stopHealthCheck() {
 function startWorkerReaper() {
     if (workerReaperTimer)
         return;
-    workerReaperTimer = setInterval(() => {
+    workerReaperTimer = setInterval(async () => {
         const maxAge = config.workerTimeoutMs * 2;
         const now = Date.now();
         for (const [name, worker] of workers) {
             if (worker.startedAt && now - worker.startedAt > maxAge) {
                 console.log(`[nzb] Reaping stuck worker '${name}' (age: ${formatAge(worker.startedAt)})`);
                 try {
-                    worker.session.disconnect().catch(() => { });
+                    await withTimeout(worker.session.disconnect(), 5_000, `reaper: worker '${name}'`);
                 }
-                catch {
-                    // Session may already be destroyed
+                catch (err) {
+                    console.error(`[nzb] Reaper: worker '${name}' disconnect failed:`, err instanceof Error ? err.message : err);
                 }
                 workers.delete(name);
                 feedBackgroundResult(name, `⚠ Worker '${name}' was automatically killed after exceeding timeout.`);
@@ -522,7 +524,10 @@ async function processQueue() {
     }
     // Re-check for messages that arrived during the last executeOnSession call
     if (messageQueue.length > 0) {
-        void processQueue();
+        processQueue().catch((err) => {
+            console.error("[nzb] processQueue re-check failed:", err instanceof Error ? err.message : err);
+            processing = false;
+        });
     }
 }
 function isRecoverableError(err) {
@@ -560,104 +565,133 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent,
     const sourceChannel = source.type === "telegram" ? "telegram" : source.type === "tui" ? "tui" : undefined;
     // Enqueue with priority — user messages go before background messages
     void (async () => {
-        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-            try {
-                const finalContent = await new Promise((resolve, reject) => {
-                    const item = {
-                        prompt: taggedPrompt,
-                        attachments,
-                        callback,
-                        onToolEvent,
-                        onUsage,
-                        sourceChannel,
-                        resolve,
-                        reject,
-                    };
-                    if (source.type === "background") {
-                        // Background results go to the back of the queue
-                        messageQueue.push(item);
-                    }
-                    else {
-                        // User messages inserted before any background messages (priority)
-                        const bgIndex = messageQueue.findIndex(isBackgroundMessage);
-                        if (bgIndex >= 0) {
-                            messageQueue.splice(bgIndex, 0, item);
+        // Safety timeout for entire message processing chain.
+        // Uses a flag to prevent double-callback if timeout fires while processing completes.
+        const GLOBAL_MSG_TIMEOUT_MS = 300_000; // 5 minutes
+        let globalTimedOut = false;
+        const globalTimer = setTimeout(() => {
+            globalTimedOut = true;
+            console.error("[nzb] Global message processing timeout (5 min). Force-failing.");
+            Promise.resolve(callback("Error: Message processing timed out after 5 minutes. Please try again.", true)).catch(() => { });
+        }, GLOBAL_MSG_TIMEOUT_MS);
+        try {
+            for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+                try {
+                    const finalContent = await new Promise((resolve, reject) => {
+                        const item = {
+                            prompt: taggedPrompt,
+                            attachments,
+                            callback,
+                            onToolEvent,
+                            onUsage,
+                            sourceChannel,
+                            resolve,
+                            reject,
+                        };
+                        if (source.type === "background") {
+                            // Background results go to the back of the queue
+                            messageQueue.push(item);
                         }
                         else {
-                            messageQueue.push(item);
+                            // User messages inserted before any background messages (priority)
+                            const bgIndex = messageQueue.findIndex(isBackgroundMessage);
+                            if (bgIndex >= 0) {
+                                messageQueue.splice(bgIndex, 0, item);
+                            }
+                            else {
+                                messageQueue.push(item);
+                            }
                         }
+                        processQueue();
+                    });
+                    // Deliver response to user FIRST, then log best-effort
+                    try {
+                        logMessage("out", sourceLabel, finalContent);
+                    }
+                    catch {
+                        /* best-effort */
+                    }
+                    // Log both sides of the conversation before delivery so we have the row ID
+                    let assistantLogId;
+                    try {
+                        const telegramMsgId = source.type === "telegram" ? source.messageId : undefined;
+                        logConversation(logRole, prompt, sourceLabel, telegramMsgId);
+                    }
+                    catch {
+                        /* best-effort */
                     }
-                    processQueue();
-                });
-                // Deliver response to user FIRST, then log best-effort
-                try {
-                    logMessage("out", sourceLabel, finalContent);
-                }
-                catch {
-                    /* best-effort */
-                }
-                // Log both sides of the conversation before delivery so we have the row ID
-                let assistantLogId;
-                try {
-                    const telegramMsgId = source.type === "telegram" ? source.messageId : undefined;
-                    logConversation(logRole, prompt, sourceLabel, telegramMsgId);
-                }
-                catch {
-                    /* best-effort */
-                }
-                try {
-                    assistantLogId = logConversation("assistant", finalContent, sourceLabel);
-                }
-                catch {
-                    /* best-effort */
-                }
-                await callback(finalContent, true, { assistantLogId });
-                // Auto-continue: if the response was cut short by timeout, automatically
-                // send a follow-up "Continue" message so the user doesn't have to
-                if (finalContent.includes("⏱ Response was cut short (timeout)") && _autoContinueCount < MAX_AUTO_CONTINUE) {
-                    console.log(`[nzb] Auto-continuing after timeout (${_autoContinueCount + 1}/${MAX_AUTO_CONTINUE})…`);
-                    await sleep(1000);
-                    void sendToOrchestrator("Continue from where you left off. Do not repeat what was already said.", source, callback, onToolEvent, onUsage, _autoContinueCount + 1);
-                }
-                return;
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                // Don't retry cancelled messages
-                if (/cancelled|abort/i.test(msg)) {
-                    return;
-                }
-                // Vision not supported — strip attachments and retry with text-only prompt.
-                // executeOnSession already destroyed the tainted session.
-                if (/not supported for vision/i.test(msg)) {
-                    console.log(`[nzb] Vision not supported — retrying without attachments`);
-                    attachments = undefined;
-                    taggedPrompt =
-                        `[System: The current model '${config.copilotModel}' does not support image/vision analysis. ` +
-                            `The image path is already included in the user's message below. ` +
-                            `Please inform the user that the current model doesn't support direct image analysis, ` +
-                            `and suggest switching to a vision-capable model (e.g. gpt-4o, claude-sonnet-4, gemini-2.0-flash) ` +
-                            `using the /model command.]\n\n${taggedPrompt}`;
-                    continue;
-                }
-                if (isRecoverableError(err) && attempt < MAX_RETRIES) {
-                    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);
-                    // Reset client before retry in case the connection is stale
                     try {
-                        await ensureClient();
+                        assistantLogId = logConversation("assistant", finalContent, sourceLabel);
                     }
                     catch {
-                        /* will fail again on next attempt */
+                        /* best-effort */
                     }
-                    continue;
+                    try {
+                        if (!globalTimedOut) {
+                            await callback(finalContent, true, { assistantLogId });
+                        }
+                    }
+                    catch (callbackErr) {
+                        console.error("[nzb] Callback error after successful response:", callbackErr instanceof Error ? callbackErr.message : callbackErr);
+                    }
+                    // Auto-continue: if the response was cut short by timeout, automatically
+                    // send a follow-up "Continue" message so the user doesn't have to
+                    if (finalContent.includes("⏱ Response was cut short (timeout)") && _autoContinueCount < MAX_AUTO_CONTINUE) {
+                        console.log(`[nzb] Auto-continuing after timeout (${_autoContinueCount + 1}/${MAX_AUTO_CONTINUE})…`);
+                        await sleep(1000);
+                        void sendToOrchestrator("Continue from where you left off. Do not repeat what was already said.", source, callback, onToolEvent, onUsage, _autoContinueCount + 1);
+                    }
+                    return;
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    // Don't retry cancelled messages
+                    if (/cancelled|abort/i.test(msg)) {
+                        if (!globalTimedOut) {
+                            try {
+                                await callback("Request was cancelled.", true);
+                            }
+                            catch { /* best-effort */ }
+                        }
+                        return;
+                    }
+                    // Vision not supported — strip attachments and retry with text-only prompt.
+                    // executeOnSession already destroyed the tainted session.
+                    if (/not supported for vision/i.test(msg)) {
+                        console.log(`[nzb] Vision not supported — retrying without attachments`);
+                        attachments = undefined;
+                        taggedPrompt =
+                            `[System: The current model '${config.copilotModel}' does not support image/vision analysis. ` +
+                                `The image path is already included in the user's message below. ` +
+                                `Please inform the user that the current model doesn't support direct image analysis, ` +
+                                `and suggest switching to a vision-capable model (e.g. gpt-4o, claude-sonnet-4, gemini-2.0-flash) ` +
+                                `using the /model command.]\n\n${taggedPrompt}`;
+                        continue;
+                    }
+                    if (isRecoverableError(err) && attempt < MAX_RETRIES) {
+                        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);
+                        // Reset client before retry in case the connection is stale
+                        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);
+                    }
+                    return;
                 }
-                console.error(`[nzb] Error processing message: ${msg}`);
-                await callback(`Error: ${msg}`, true);
-                return;
             }
         }
+        finally {
+            clearTimeout(globalTimer);
+        }
     })().catch((err) => {
         console.error(`[nzb] Unhandled error in sendToOrchestrator: ${err instanceof Error ? err.message : String(err)}`);
     });

package/dist/copilot/tools.js

@@ -6,6 +6,7 @@ import { z } from "zod";
 import { config, persistModel } from "../config.js";
 import { SESSIONS_DIR } from "../paths.js";
 import { getDb } from "../store/db.js";
+import { withTimeout } from "../utils.js";
 import { addMemory, removeMemory, searchMemories } from "../store/memory.js";
 import { createSkill, listSkills, removeSkill } from "./skills.js";
 function isTimeoutError(err) {
@@ -111,7 +112,9 @@ export function createTools(deps) {
                     })
                         .finally(() => {
                         // Auto-destroy background workers after completion to free memory (~400MB per worker)
-                        session.disconnect().catch(() => { });
+                        withTimeout(session.disconnect(), 5_000, `worker '${args.name}' disconnect`).catch((err) => {
+                            console.error(`[nzb] Worker '${args.name}' disconnect timeout/error:`, err instanceof Error ? err.message : err);
+                        });
                         deps.workers.delete(args.name);
                         try {
                             getDb().prepare(`DELETE FROM worker_sessions WHERE name = ?`).run(args.name);
@@ -162,7 +165,9 @@ export function createTools(deps) {
                 })
                     .finally(() => {
                     // Auto-destroy after each send_to_worker dispatch to free memory
-                    worker.session.disconnect().catch(() => { });
+                    withTimeout(worker.session.disconnect(), 5_000, `worker '${args.name}' disconnect`).catch((err) => {
+                        console.error(`[nzb] Worker '${args.name}' disconnect timeout/error:`, err instanceof Error ? err.message : err);
+                    });
                     deps.workers.delete(args.name);
                     try {
                         getDb().prepare(`DELETE FROM worker_sessions WHERE name = ?`).run(args.name);
@@ -210,10 +215,10 @@ export function createTools(deps) {
                     return `No worker named '${args.name}'.`;
                 }
                 try {
-                    await worker.session.disconnect();
+                    await withTimeout(worker.session.disconnect(), 5_000, `worker '${args.name}' disconnect`);
                 }
-                catch {
-                    // Session may already be gone
+                catch (err) {
+                    console.error(`[nzb] Worker '${args.name}' disconnect timeout/error:`, err instanceof Error ? err.message : err);
                 }
                 deps.workers.delete(args.name);
                 const db = getDb();
@@ -232,7 +237,9 @@ export function createTools(deps) {
                 if (!worker)
                     return `No worker found with name '${args.name}'.`;
                 try {
-                    worker.session.disconnect().catch(() => { });
+                    withTimeout(worker.session.disconnect(), 5_000, `worker '${args.name}' disconnect`).catch((err) => {
+                        console.error(`[nzb] Worker '${args.name}' disconnect timeout/error:`, err instanceof Error ? err.message : err);
+                    });
                 }
                 catch {
                     // Session may already be destroyed
@@ -347,7 +354,9 @@ export function createTools(deps) {
                             deps.onWorkerComplete(member.name, errMsg);
                         })
                             .finally(() => {
-                            session.disconnect().catch(() => { });
+                            withTimeout(session.disconnect(), 5_000, `worker '${member.name}' disconnect`).catch((err) => {
+                                console.error(`[nzb] Worker '${member.name}' disconnect timeout/error:`, err instanceof Error ? err.message : err);
+                            });
                             deps.workers.delete(member.name);
                             try {
                                 getDb().prepare(`DELETE FROM worker_sessions WHERE name = ?`).run(member.name);

package/dist/store/db.js

@@ -8,6 +8,7 @@ export function getDb() {
         ensureNZBHome();
         db = new Database(DB_PATH);
         db.pragma("journal_mode = WAL");
+        db.pragma("busy_timeout = 5000");
         db.exec(`
       CREATE TABLE IF NOT EXISTS worker_sessions (
         id INTEGER PRIMARY KEY AUTOINCREMENT,

package/dist/telegram/bot.js

@@ -25,6 +25,8 @@ const startedAt = Date.now();
 const INITIAL_POLL_RETRY_DELAY = 5000;
 const MAX_POLL_RETRY_DELAY = 300_000; // 5 minutes
 let pollRetryDelay = INITIAL_POLL_RETRY_DELAY;
+let consecutivePollingFailures = 0;
+const MAX_CONSECUTIVE_POLLING_FAILURES = 10;
 // Direct-connection HTTPS agent for Telegram API requests.
 // This bypasses corporate proxy (HTTP_PROXY/HTTPS_PROXY env vars) without
 // modifying process.env, so other services (Copilot SDK, MCP, npm) are unaffected.
@@ -177,15 +179,21 @@ export async function startBot() {
         ...(savedOffset ? { offset: savedOffset + 1 } : {}),
         onStart: () => {
             console.log("[nzb] Telegram bot connected");
+            consecutivePollingFailures = 0;
             pollRetryDelay = INITIAL_POLL_RETRY_DELAY;
             void logInfo(`🚀 NZB v${process.env.npm_package_version || "?"} started (model: ${config.copilotModel})`);
         },
     })
         .catch(async (err) => {
+        consecutivePollingFailures++;
         if (err?.error_code === 401) {
             console.error("[nzb] Warning: Telegram bot token is invalid or expired. Run 'nzb setup' and re-enter your bot token from @BotFather.");
             return; // Unrecoverable — don't retry
         }
+        if (consecutivePollingFailures >= MAX_CONSECUTIVE_POLLING_FAILURES) {
+            console.error(`[nzb] Telegram polling failed ${consecutivePollingFailures} consecutive times. Stopping retry attempts. Restart NZB to try again.`);
+            return;
+        }
         if (err?.error_code === 409) {
             console.error(`[nzb] Warning: Telegram polling conflict (409). Restarting polling in ${pollRetryDelay / 1000}s...`);
         }

package/package.json

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