@iletai/nzb 1.7.0 → 1.7.3

package/dist/telegram/bot.js

@@ -1,8 +1,11 @@
 import { autoRetry } from "@grammyjs/auto-retry";
 import { sequentialize } from "@grammyjs/runner";
 import { apiThrottler } from "@grammyjs/transformer-throttler";
+import { realpathSync } from "fs";
 import { Bot, Keyboard } from "grammy";
 import { Agent as HttpsAgent } from "https";
+import { tmpdir } from "os";
+import { resolve as pathResolve } from "path";
 import { config } from "../config.js";
 import { getPersistedUpdateOffset, isUpdateDuplicate, persistUpdateOffset } from "./dedup.js";
 import { registerCallbackHandlers } from "./handlers/callbacks.js";
@@ -19,6 +22,9 @@ let bot;
 /** Abort controller for graceful fetch abort on shutdown — prevents 30s getUpdates hang and 409 conflicts. */
 let fetchAbortController;
 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;
 // 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.
@@ -171,6 +177,7 @@ export async function startBot() {
         ...(savedOffset ? { offset: savedOffset + 1 } : {}),
         onStart: () => {
             console.log("[nzb] Telegram bot connected");
+            pollRetryDelay = INITIAL_POLL_RETRY_DELAY;
             void logInfo(`🚀 NZB v${process.env.npm_package_version || "?"} started (model: ${config.copilotModel})`);
         },
     })
@@ -180,13 +187,14 @@ export async function startBot() {
             return; // Unrecoverable — don't retry
         }
         if (err?.error_code === 409) {
-            console.error("[nzb] Warning: Telegram polling conflict (409). Restarting polling in 5 seconds...");
+            console.error(`[nzb] Warning: Telegram polling conflict (409). Restarting polling in ${pollRetryDelay / 1000}s...`);
         }
         else {
-            console.error("[nzb] Error: Telegram polling stopped:", err?.message || err, "— restarting in 5 seconds...");
+            console.error("[nzb] Error: Telegram polling stopped:", err?.message || err, `— restarting in ${pollRetryDelay / 1000}s...`);
         }
-        // Auto-restart polling after a delay
-        await new Promise((r) => setTimeout(r, 5000));
+        // Auto-restart polling with exponential backoff
+        await new Promise((r) => setTimeout(r, pollRetryDelay));
+        pollRetryDelay = Math.min(pollRetryDelay * 2, MAX_POLL_RETRY_DELAY);
         if (bot) {
             console.log("[nzb] Re-starting Telegram polling...");
             startBot().catch((e) => console.error("[nzb] Failed to re-start Telegram polling:", e));
@@ -215,17 +223,78 @@ export async function sendWorkerNotification(message) {
         const { truncateForTelegram } = await import("./formatter.js");
         await bot.api.sendMessage(config.authorizedUserId, truncateForTelegram(message));
     }
+    catch (err) {
+        console.error("[nzb] Worker notification failed:", err instanceof Error ? err.message : err);
+    }
+}
+/** Check if a URL points to an internal/private network address. */
+function isInternalUrl(urlStr) {
+    try {
+        const url = new URL(urlStr);
+        const hostname = url.hostname.replace(/^\[|\]$/g, ""); // Strip IPv6 brackets
+        if (hostname === "localhost" || hostname === "0.0.0.0" || hostname === "::1")
+            return true;
+        if (hostname.startsWith("127."))
+            return true; // Entire 127.0.0.0/8 loopback range
+        if (hostname.startsWith("10."))
+            return true;
+        if (hostname.startsWith("172.") &&
+            parseInt(hostname.split(".")[1]) >= 16 &&
+            parseInt(hostname.split(".")[1]) <= 31)
+            return true;
+        if (hostname.startsWith("192.168."))
+            return true;
+        if (hostname.startsWith("169.254."))
+            return true; // Entire 169.254.0.0/16 link-local range
+        if (hostname.endsWith(".internal") || hostname.endsWith(".local"))
+            return true;
+        // IPv6 private/link-local: fe80::/10, fc00::/7 (fd00::/8), IPv4-mapped ::ffff:x
+        if (/^(fe[89ab][0-9a-f]|f[cd][0-9a-f]{2}):/i.test(hostname))
+            return true;
+        if (hostname.startsWith("::ffff:"))
+            return true;
+        return false;
+    }
     catch {
-        // best-effort — don't crash if notification fails
+        // Expected: invalid URL treated as internal for safety
+        return true;
     }
 }
-/** Send a photo to the authorized user. Accepts a file path or URL. */
+/** Allowlisted directories for local file photo access. */
+const PHOTO_ALLOWED_DIRS = [tmpdir(), "/tmp"];
+/** Validate a local file path is within allowed directories. */
+function isAllowedFilePath(filePath) {
+    try {
+        const resolved = realpathSync(pathResolve(filePath));
+        return PHOTO_ALLOWED_DIRS.some((dir) => resolved.startsWith(dir));
+    }
+    catch {
+        // Expected: file may not exist or path may be inaccessible
+        return false;
+    }
+}
+/** Send a photo to the authorized user. Accepts a file path or HTTPS URL. */
 export async function sendPhoto(photo, caption) {
     if (!bot || config.authorizedUserId === undefined)
         return;
-    try {
+    let input;
+    if (photo.startsWith("https://")) {
+        if (isInternalUrl(photo)) {
+            throw new Error("URL points to an internal/private network address");
+        }
+        input = photo;
+    }
+    else if (photo.startsWith("http://")) {
+        throw new Error("Only HTTPS URLs are allowed for photos");
+    }
+    else {
+        if (!isAllowedFilePath(photo)) {
+            throw new Error("File path is not within allowed directories");
+        }
         const { InputFile } = await import("grammy");
-        const input = photo.startsWith("http") ? photo : new InputFile(photo);
+        input = new InputFile(photo);
+    }
+    try {
         await bot.api.sendPhoto(config.authorizedUserId, input, {
             caption,
         });

package/dist/telegram/handlers/commands.js

@@ -2,7 +2,7 @@ import { config, persistEnvVar, persistModel } from "../../config.js";
 import { cancelCurrentMessage, compactSession, getQueueSize, getWorkers, resetSession, } from "../../copilot/orchestrator.js";
 import { listSkills } from "../../copilot/skills.js";
 import { restartDaemon } from "../../daemon.js";
-import { searchMemories } from "../../store/db.js";
+import { searchMemories } from "../../store/memory.js";
 import { chunkMessage } from "../formatter.js";
 import { buildSettingsText, formatMemoryList } from "../menus.js";
 import { getReactionHelpText } from "./reactions.js";

package/dist/telegram/handlers/media.js

@@ -1,7 +1,19 @@
 import { config } from "../../config.js";
 import { sendToOrchestrator } from "../../copilot/orchestrator.js";
 import { logInfo } from "../log-channel.js";
-import { sendFormattedReply, scheduleTempCleanup } from "./helpers.js";
+import { scheduleTempCleanup, sendFormattedReply } from "./helpers.js";
+const MEDIA_DOWNLOAD_TIMEOUT_MS = 30_000;
+/** Fetch with an AbortController timeout. Throws AbortError on timeout. */
+async function fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), MEDIA_DOWNLOAD_TIMEOUT_MS);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 /** Register photo, document, and voice message handlers on the bot. */
 export function registerMediaHandlers(bot) {
     // Handle photo messages — download and pass to AI
@@ -23,13 +35,34 @@ export function registerMediaHandlers(bot) {
                 return;
             }
             const url = `https://api.telegram.org/file/bot${config.telegramBotToken}/${filePath}`;
-            const response = await fetch(url);
+            let response;
+            try {
+                response = await fetchWithTimeout(url);
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === "AbortError") {
+                    await ctx.reply("⏱ Media download timed out. Please try again.", {
+                        reply_parameters: { message_id: userMessageId },
+                    });
+                    return;
+                }
+                throw err;
+            }
             const buffer = Buffer.from(await response.arrayBuffer());
             const base64Data = buffer.toString("base64");
             const ext = filePath.split(".").pop() || "jpg";
             const mimeType = ext === "png" ? "image/png" : ext === "gif" ? "image/gif" : "image/jpeg";
+            // Save to disk first as fallback — if vision fails, the AI can still reference the file
+            const { mkdtempSync, writeFileSync } = await import("fs");
+            const { join } = await import("path");
+            const { tmpdir } = await import("os");
+            const tmpDir = mkdtempSync(join(tmpdir(), "nzb-photo-"));
+            const localPath = join(tmpDir, `photo.${ext}`);
+            writeFileSync(localPath, buffer);
+            scheduleTempCleanup(tmpDir);
             const attachment = { type: "blob", data: base64Data, mimeType };
-            sendToOrchestrator(caption, { type: "telegram", chatId, messageId: userMessageId }, (text, done) => {
+            const promptWithPath = `${caption}\n\n[Image also saved to: ${localPath}]`;
+            sendToOrchestrator(promptWithPath, { type: "telegram", chatId, messageId: userMessageId }, (text, done) => {
                 if (done)
                     void sendFormattedReply(bot, chatId, text, { replyTo: userMessageId });
             }, undefined, undefined, 0, [attachment]);
@@ -68,7 +101,19 @@ export function registerMediaHandlers(bot) {
             const { tmpdir } = await import("os");
             const tmpDir = mkdtempSync(join(tmpdir(), "nzb-doc-"));
             const localPath = join(tmpDir, doc.file_name || "file");
-            const response = await fetch(url);
+            let response;
+            try {
+                response = await fetchWithTimeout(url);
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === "AbortError") {
+                    await ctx.reply("⏱ Media download timed out. Please try again.", {
+                        reply_parameters: { message_id: userMessageId },
+                    });
+                    return;
+                }
+                throw err;
+            }
             const buffer = Buffer.from(await response.arrayBuffer());
             writeFileSync(localPath, buffer);
             scheduleTempCleanup(tmpDir);
@@ -126,7 +171,19 @@ export function registerMediaHandlers(bot) {
             const tmpDir = mkdtempSync(join(tmpdir(), "nzb-voice-"));
             const ext = filePath.split(".").pop() || "oga";
             const localPath = join(tmpDir, `voice.${ext}`);
-            const response = await fetch(url);
+            let response;
+            try {
+                response = await fetchWithTimeout(url);
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === "AbortError") {
+                    await ctx.reply("⏱ Media download timed out. Please try again.", {
+                        reply_parameters: { message_id: userMessageId },
+                    });
+                    return;
+                }
+                throw err;
+            }
             const buffer = Buffer.from(await response.arrayBuffer());
             writeFileSync(localPath, buffer);
             scheduleTempCleanup(tmpDir);
@@ -136,7 +193,7 @@ export function registerMediaHandlers(bot) {
                     const formData = new FormData();
                     formData.append("file", new Blob([buffer], { type: "audio/ogg" }), `voice.${ext}`);
                     formData.append("model", "whisper-1");
-                    const whisperResp = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+                    const whisperResp = await fetchWithTimeout("https://api.openai.com/v1/audio/transcriptions", {
                         method: "POST",
                         headers: { Authorization: `Bearer ${config.openaiApiKey}` },
                         body: formData,