@emaxe/tuigram 1.3.0 → 1.5.0

package/src/cli/videoSetup.js

@@ -0,0 +1,187 @@
+/**
+ * Консольная команда установки и настройки зависимостей для воспроизведения видео.
+ * Проверяет наличие ffmpeg, скачивает статическую сборку при необходимости
+ * и активирует функционал ENABLE_VIDEO=true в файле настроек .env.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import https from "node:https";
+import { spawnSync } from "node:child_process";
+import { bold, cyan, green, yellow, dim, red } from "colorette";
+import { config } from "../config.js";
+import { upsertEnv } from "./init.js";
+import { findFfmpegPath, findFfplayPath, extractFirstFileFromZip } from "../utils/video.js";
+
+/** Ссылки на стабильные статические сборки ffmpeg по платформам. */
+const FFMPEG_URLS = {
+    "darwin:x64": "https://github.com/ffbinaries/ffbinaries-prebuilt/releases/download/v4.4.1/ffmpeg-4.4.1-osx-64.zip",
+    "darwin:arm64": "https://github.com/ffbinaries/ffbinaries-prebuilt/releases/download/v4.4.1/ffmpeg-4.4.1-osx-64.zip",
+    "linux:x64": "https://github.com/ffbinaries/ffbinaries-prebuilt/releases/download/v4.4.1/ffmpeg-4.4.1-linux-64.zip",
+    "linux:arm64": "https://github.com/ffbinaries/ffbinaries-prebuilt/releases/download/v4.4.1/ffmpeg-4.4.1-linux-arm-64.zip",
+    "linux:arm": "https://github.com/ffbinaries/ffbinaries-prebuilt/releases/download/v4.4.1/ffmpeg-4.4.1-linux-armel-32.zip",
+    "win32:x64": "https://github.com/ffbinaries/ffbinaries-prebuilt/releases/download/v4.4.1/ffmpeg-4.4.1-win-64.zip",
+    "win32:ia32": "https://github.com/ffbinaries/ffbinaries-prebuilt/releases/download/v4.4.1/ffmpeg-4.4.1-win-32.zip",
+};
+
+/**
+ * Скачивает буфер по URL с поддержкой HTTP(S) редиректов.
+ * @param {string} targetUrl
+ * @param {number} [redirects=0]
+ * @returns {Promise<Buffer>}
+ */
+function fetchBuffer(targetUrl, redirects = 0) {
+    return new Promise((resolve, reject) => {
+        if (redirects > 5) {
+            return reject(new Error("Слишком много редиректов при загрузке"));
+        }
+        https.get(targetUrl, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return resolve(fetchBuffer(res.headers.location, redirects + 1));
+            }
+            if (res.statusCode !== 200) {
+                return reject(new Error(`Ошибка HTTP ${res.statusCode}: ${res.statusMessage}`));
+            }
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => resolve(Buffer.concat(chunks)));
+            res.on("error", reject);
+        }).on("error", reject);
+    });
+}
+
+/**
+ * Активирует флаг ENABLE_VIDEO=true в .env файлах.
+ * @returns {string[]} список обновлённых файлов
+ */
+export function enableVideoInEnv() {
+    const updated = [];
+    const targets = [config.configEnvPath];
+
+    const localEnv = path.join(config.packageRoot, ".env");
+    if (fs.existsSync(localEnv) && localEnv !== config.configEnvPath) {
+        targets.push(localEnv);
+    }
+
+    for (const target of targets) {
+        try {
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            let text = "";
+            try {
+                text = fs.readFileSync(target, "utf8");
+            } catch {
+                text = "# TuiGram настройки\n";
+            }
+            const newText = upsertEnv(text, { ENABLE_VIDEO: "true" });
+            fs.writeFileSync(target, newText, { encoding: "utf8", mode: 0o600 });
+            updated.push(target);
+        } catch {
+            // Игнорируем ошибку записи отдельного файла
+        }
+    }
+
+    return updated;
+}
+
+/**
+ * Консольная команда установки зависимостей для видео (`tuigram install-video`).
+ * @param {Record<string, string|boolean>} [flags]
+ * @returns {Promise<void>}
+ */
+export function cmdInstallVideo(flags = {}) {
+    return (async () => {
+        console.log(bold("\n🎬 TuiGram — Установка поддержки воспроизведения видео\n"));
+
+        const existingFfmpeg = findFfmpegPath();
+        const force = Boolean(flags.force);
+
+        if (existingFfmpeg && !force) {
+            console.log(green(`✓ ffmpeg обнаружен: ${existingFfmpeg}`));
+            try {
+                const ver = spawnSync(existingFfmpeg, ["-version"], { encoding: "utf8", timeout: 2000 });
+                if (ver.stdout) {
+                    const firstLine = ver.stdout.trim().split(/\r?\n/)[0];
+                    console.log(dim(`  Версия: ${firstLine}`));
+                }
+            } catch {
+                // Игнорируем
+            }
+
+            const updated = enableVideoInEnv();
+            console.log(green("\n✓ Опция ENABLE_VIDEO=true активирована в .env!"));
+            for (const file of updated) {
+                console.log(dim(`  Файл: ${file}`));
+            }
+
+            printUsageInstructions();
+            return;
+        }
+
+        const platformKey = `${process.platform}:${process.arch}`;
+        const downloadUrl = FFMPEG_URLS[platformKey] || FFMPEG_URLS[`${process.platform}:x64`];
+
+        if (!downloadUrl) {
+            console.log(yellow(`Платформа ${platformKey} не поддерживает автоматическую загрузку бинарника.`));
+            printManualInstallInstructions();
+            return;
+        }
+
+        console.log(`Платформа: ${cyan(platformKey)}`);
+        console.log(`Загрузка статической сборки ffmpeg из GitHub Releases...`);
+        console.log(dim(`URL: ${downloadUrl}\n`));
+
+        try {
+            const zipBuffer = await fetchBuffer(downloadUrl);
+            console.log(`✓ Загружено ${Math.round(zipBuffer.length / 1024 / 1024 * 10) / 10} MB. Распаковка...`);
+
+            const { data } = extractFirstFileFromZip(zipBuffer);
+            const binDir = path.join(config.dataDir, "bin");
+            fs.mkdirSync(binDir, { recursive: true });
+
+            const isWin = process.platform === "win32";
+            const binaryName = isWin ? "ffmpeg.exe" : "ffmpeg";
+            const destPath = path.join(binDir, binaryName);
+
+            fs.writeFileSync(destPath, data, { mode: 0o755 });
+            fs.chmodSync(destPath, 0o755);
+
+            // Проверка запуска
+            const testRun = spawnSync(destPath, ["-version"], { encoding: "utf8", timeout: 3000 });
+            if (testRun.status !== 0) {
+                throw new Error(`Бинарник не запустился (код ошибки: ${testRun.status})`);
+            }
+
+            console.log(green(`✓ ffmpeg успешно установлен: ${destPath}`));
+
+            const updated = enableVideoInEnv();
+            console.log(green("✓ Опция ENABLE_VIDEO=true активирована в .env!"));
+            for (const file of updated) {
+                console.log(dim(`  Файл: ${file}`));
+            }
+
+            printUsageInstructions();
+        } catch (err) {
+            console.error(red(`\nОшибка автоматической установки ffmpeg: ${err.message}`));
+            printManualInstallInstructions();
+        }
+    })();
+}
+
+function printUsageInstructions() {
+    console.log(bold("\n▶ Как воспроизводить видео в TuiGram:"));
+    console.log("  1. Запустите TUI интерфейс: tuigram (или npm start)");
+    console.log("  2. В ленте чата кликните мышью по превью видео");
+    console.log("     или выберите сообщение и нажмите Enter → «Воспроизвести видео»");
+    console.log("  3. Управление в плеере: [Пробел] — пауза/воспроизведение, [r] — с начала, [Esc] или [q] — закрыть.\n");
+}
+
+function printManualInstallInstructions() {
+    console.log(bold("\n📦 Установка ffmpeg вручную через системный пакетный менеджер:"));
+    console.log("  • macOS (Homebrew):     brew install ffmpeg");
+    console.log("  • Ubuntu / Debian:       sudo apt update && sudo apt install -y ffmpeg");
+    console.log("  • Arch Linux:            sudo pacman -S ffmpeg");
+    console.log("  • Fedora:                sudo dnf install ffmpeg");
+    console.log("  • Windows (winget):      winget install Gyan.FFmpeg\n");
+    console.log("После установки добавьте в ваш .env файл:");
+    console.log(cyan("  ENABLE_VIDEO=true\n"));
+}

package/src/config.js

@@ -255,6 +255,12 @@ export const config = {
     imageMaxWidth: parseInt(process.env.IMAGE_MAX_WIDTH || "36", 10) || 36,
     imageMaxHeight: parseInt(process.env.IMAGE_MAX_HEIGHT || "14", 10) || 14,
 
+    enableVideo: String(process.env.ENABLE_VIDEO || process.env.ENABLE_VIDEO_PLAYBACK || "false").toLowerCase() === "true",
+    videoFps: Math.min(30, Math.max(1, parseInt(process.env.VIDEO_FPS || "15", 10) || 15)),
+    videoAudio: String(process.env.VIDEO_AUDIO || "true").toLowerCase() !== "false",
+    ffmpegPath: process.env.FFMPEG_PATH || null,
+    ffplayPath: process.env.FFPLAY_PATH || null,
+
     proxy: parseProxyConfig(),
 
     /**

package/src/index.js

@@ -14,6 +14,7 @@ import {
     cmdListen
 } from "./cli/cliCommands.js";
 import { cmdInit, cmdPaths } from "./cli/init.js";
+import { cmdInstallVideo } from "./cli/videoSetup.js";
 import { config } from "./config.js";
 import { red, bold } from "colorette";
 
@@ -57,6 +58,7 @@ ${bold("Настройка:")}
   tuigram init                   Ввести ключи Telegram API (api_id / api_hash)
                                  --api-id <ID> --api-hash <HASH>  без диалога
   tuigram paths                  Показать пути к настройкам, сессии и загрузкам
+  tuigram install-video          Установить ffmpeg и включить воспроизведение видео
 
 ${bold("Консольные команды (CLI):")}
   tuigram login                  Авторизация в аккаунте (телефон, код, 2FA)
@@ -104,6 +106,12 @@ async function main() {
             cmdPaths();
             process.exit(0);
             break;
+        case "install-video":
+        case "setup-video":
+        case "install-deps":
+            await cmdInstallVideo(flags);
+            process.exit(0);
+            break;
         case "login":
             await cmdLogin();
             process.exit(0);

package/src/state.js

@@ -45,7 +45,7 @@ class AppState extends EventEmitter {
      * @returns {Array<object>}
      */
     getVisibleDialogs() {
-        const tabFiltered = filterDialogsByTab(this.dialogs, this.currentFilterTab);
+        const tabFiltered = filterDialogsByTab(this.dialogs, this.currentFilterTab, this.activeChat?.id);
         if (!this.searchQuery) return tabFiltered;
         return searchDialogs(tabFiltered, this.searchQuery);
     }
@@ -97,13 +97,34 @@ class AppState extends EventEmitter {
         this.replyTarget = null;
         this.editTarget = null;
         this.selectedMessageIndex = -1;
-        if (dialog) {
-            dialog.unreadCount = 0;
-            dialog.unreadMentionsCount = 0;
-        }
         this.emit("active_chat_changed", dialog);
     }
 
+    /**
+     * Обновляет счётчик непрочитанных сообщений и максимальный прочитанный ID диалога.
+     * @param {string} chatId
+     * @param {number} unreadCount
+     * @param {number} [readInboxMaxId]
+     */
+    updateDialogUnread(chatId, unreadCount, readInboxMaxId) {
+        const dialog = this.dialogs.find((d) => d.id === chatId);
+        if (!dialog) return;
+
+        const countChanged = dialog.unreadCount !== unreadCount;
+        const idChanged = typeof readInboxMaxId === "number" && readInboxMaxId > (dialog.readInboxMaxId || 0);
+
+        if (countChanged || idChanged) {
+            dialog.unreadCount = Math.max(0, unreadCount);
+            if (dialog.unreadCount === 0) {
+                dialog.unreadMentionsCount = 0;
+            }
+            if (idChanged) {
+                dialog.readInboxMaxId = readInboxMaxId;
+            }
+            this.emit("dialogs_updated", this.getVisibleDialogs());
+        }
+    }
+
     /**
      * Получает список сообщений для указанного чата.
      * @param {string} chatId
@@ -117,9 +138,11 @@ class AppState extends EventEmitter {
      * Устанавливает или дополняет список сообщений для чата.
      * @param {string} chatId
      * @param {Array<object>} newMessages
-     * @param {boolean} [prepend=false] Если true — добавляет старые сообщения в начало
+     * @param {boolean|object} [options=false] Если true — добавляет старые сообщения в начало
      */
-    setMessages(chatId, newMessages, prepend = false) {
+    setMessages(chatId, newMessages, options = false) {
+        const prepend = typeof options === "boolean" ? options : Boolean(options?.prepend);
+        const firstUnreadId = typeof options === "object" ? (options?.firstUnreadId || null) : null;
         const existing = this.messagesByChat.get(chatId) || [];
         let combined = [];
 
@@ -140,7 +163,7 @@ class AppState extends EventEmitter {
         combined.sort((a, b) => (a.date || 0) - (b.date || 0) || (a.id - b.id));
 
         this.messagesByChat.set(chatId, combined);
-        this.emit("messages_updated", { chatId, messages: combined, isPrepend: prepend, isUpdate: false });
+        this.emit("messages_updated", { chatId, messages: combined, isPrepend: prepend, isUpdate: false, firstUnreadId });
     }
 
     /**

package/src/telegram/dialogs.js

@@ -37,6 +37,9 @@ export function normalizeDialog(dialog) {
         archived: Boolean(dialog.archived),
         unreadCount: dialog.unreadCount || 0,
         unreadMentionsCount: dialog.unreadMentionsCount || 0,
+        readInboxMaxId: dialog.dialog?.readInboxMaxId || dialog.readInboxMaxId || 0,
+        readOutboxMaxId: dialog.dialog?.readOutboxMaxId || dialog.readOutboxMaxId || 0,
+        topMessage: dialog.dialog?.topMessage || message?.id || 0,
         folderId: dialog.folderId || 0,
         date: dialog.date ? dialog.date * 1000 : (message?.date ? message.date * 1000 : Date.now()),
         isMuted: Boolean(dialog.dialog?.notifySettings?.muteUntil > 0),
@@ -86,9 +89,10 @@ export async function fetchDialogs(client, { limit = 100, archived } = {}) {
  * Фильтрует список диалогов по выбранной категории.
  * @param {Array<object>} dialogs
  * @param {"all"|"users"|"groups"|"channels"|"bots"|"unread"|"archived"} filterTab
+ * @param {string|null} [activeChatId=null] ID активного чата (не исключается из вкладки непрочитанных)
  * @returns {Array<object>}
  */
-export function filterDialogsByTab(dialogs, filterTab = "all") {
+export function filterDialogsByTab(dialogs, filterTab = "all", activeChatId = null) {
     if (!dialogs) return [];
 
     switch (filterTab) {
@@ -101,7 +105,7 @@ export function filterDialogsByTab(dialogs, filterTab = "all") {
         case "bots":
             return dialogs.filter((d) => !d.archived && d.type === "bot");
         case "unread":
-            return dialogs.filter((d) => !d.archived && (d.unreadCount > 0 || d.unreadMentionsCount > 0));
+            return dialogs.filter((d) => !d.archived && (d.unreadCount > 0 || d.unreadMentionsCount > 0 || (activeChatId && d.id === activeChatId)));
         case "archived":
             return dialogs.filter((d) => d.archived);
         case "all":

package/src/telegram/formatter.js

@@ -70,7 +70,7 @@ export function setMessagePalette(theme) {
  */
 export function escapeBlessed(text) {
     if (!text) return "";
-    return String(text).replace(/\{/g, "\\{").replace(/\}/g, "\\}");
+    return String(text).replace(/[{}]/g, (ch) => (ch === "{" ? "{open}" : "{close}"));
 }
 
 /**

package/src/telegram/messages.js

@@ -2,10 +2,43 @@ import { Api, errors } from "teleproto";
 import { idToString, toMarkedId, getEntityDisplayName, entityCache, resolveEntity } from "./entities.js";
 import { describeMedia } from "./formatter.js";
 import { config } from "../config.js";
-import { renderStrippedThumbnail, renderImageBuffer } from "../utils/image.js";
+import { renderStrippedThumbnail, renderImageBuffer, renderMediaPreloader, getCachedImagePreview, isPreviewableMedia } from "../utils/image.js";
 
 const { FloodWaitError } = errors;
 
+/**
+ * Синхронно рисует миниатюру, встроенную в само сообщение (PhotoStrippedSize).
+ * Сеть не нужна — байты уже пришли вместе с сообщением, поэтому картинку можно
+ * показать мгновенно, пока качается полноразмерная версия.
+ * @param {object} rawMessage
+ * @param {object} [options]
+ * @param {number} [options.maxWidth]
+ * @param {number} [options.maxHeight]
+ * @param {boolean} [options.useCache=true] класть результат в кэш псевдографики
+ * @returns {string} разметка blessed или пустая строка
+ */
+export function renderMessageThumbnail(rawMessage, {
+    maxWidth = config.imageMaxWidth,
+    maxHeight = config.imageMaxHeight,
+    useCache = true,
+} = {}) {
+    const media = rawMessage?.media;
+    if (!media) return "";
+
+    const photo = media.photo;
+    const doc = media.document;
+    const sizes = photo?.sizes || doc?.thumbs || [];
+    const stripped = sizes.find((s) => s?.className === "PhotoStrippedSize" || s?.type === "i" || (s?.bytes && s.bytes.length > 0));
+    if (!stripped?.bytes) return "";
+
+    // Полноэкранные рендеры не кэшируем: одна такая строка весит сотни килобайт
+    const cacheKey = useCache
+        ? (photo?.id ? `photo_${photo.id}` : (doc?.id ? `doc_${doc.id}` : `msg_${rawMessage.id}`))
+        : undefined;
+
+    return renderStrippedThumbnail(stripped.bytes, { maxWidth, maxHeight, cacheKey }) || "";
+}
+
 /**
  * Преобразует объект Message из MTProto в нормализованный объект для TUI.
  * @param {object} message
@@ -40,24 +73,30 @@ export function normalizeMessage(message) {
         }
     }
 
-    // Извлечение и рендеринг PhotoStrippedSize в псевдографику
+    // Извлечение и рендеринг PhotoStrippedSize в псевдографику или прелоадера
     let imagePreview = null;
-    if (config.showImages && message.media) {
-        const media = message.media;
-        const photo = media.photo;
-        const doc = media.document;
-        const sizes = photo?.sizes || doc?.thumbs || [];
-        const stripped = sizes.find((s) => s?.className === "PhotoStrippedSize" || s?.type === "i" || (s?.bytes && s.bytes.length > 0));
-
-        if (stripped?.bytes) {
-            const cacheKey = photo?.id
-                ? `photo_${photo.id}`
-                : (doc?.id ? `doc_${doc.id}` : `msg_${message.id}`);
-            imagePreview = renderStrippedThumbnail(stripped.bytes, {
-                maxWidth: config.imageMaxWidth,
-                maxHeight: config.imageMaxHeight,
-                cacheKey,
-            }) || null;
+    let isPreviewLoading = false;
+
+    if (config.showImages && isPreviewableMedia(message)) {
+        const cached = getCachedImagePreview(message, {
+            maxWidth: config.imageMaxWidth,
+            maxHeight: config.imageMaxHeight,
+        });
+        if (cached) {
+            imagePreview = cached;
+            isPreviewLoading = false;
+        } else {
+            const strippedThumb = renderMessageThumbnail(message);
+            if (strippedThumb) {
+                imagePreview = strippedThumb;
+                isPreviewLoading = false;
+            } else {
+                imagePreview = renderMediaPreloader(message, {
+                    maxWidth: config.imageMaxWidth,
+                    maxHeight: config.imageMaxHeight,
+                });
+                isPreviewLoading = true;
+            }
         }
     }
 
@@ -77,6 +116,7 @@ export function normalizeMessage(message) {
         media: message.media || null,
         mediaDescription: describeMedia(message.media),
         imagePreview,
+        isPreviewLoading,
         entities: message.entities || [],
         reactions,
         rawMessage: message,
@@ -103,6 +143,9 @@ export async function fetchHistory(client, rawPeer, { limit = 40, offsetId = 0,
                 messages.push(normalizeMessage(msg));
             }
         }
+        if (!reverse) {
+            messages.reverse();
+        }
     };
 
     try {
@@ -269,6 +312,61 @@ export async function sendReaction(client, rawPeer, messageId, emoji = "👍") {
     );
 }
 
+/**
+ * Находит первое непрочитанное входящее сообщение в хронологическом списке сообщений.
+ * @param {Array<object>} messages
+ * @param {object} [options]
+ * @param {number} [options.readInboxMaxId=0]
+ * @param {number} [options.unreadCount=0]
+ * @returns {object|null}
+ */
+export function findFirstUnreadMessage(messages, { readInboxMaxId = 0, unreadCount = 0 } = {}) {
+    if (!Array.isArray(messages) || messages.length === 0 || unreadCount === 0) {
+        return null;
+    }
+
+    // Всегда сортируем сообщения по возрастанию ID/даты перед поиском
+    const sorted = [...messages].sort((a, b) => (a.date || 0) - (b.date || 0) || (a.id - b.id));
+
+    if (readInboxMaxId > 0) {
+        const first = sorted.find((m) => !m.out && m.id > readInboxMaxId);
+        if (first) return first;
+    }
+
+    if (unreadCount > 0) {
+        const incoming = sorted.filter((m) => !m.out);
+        if (incoming.length > 0) {
+            const unreadIncoming = incoming.slice(-unreadCount);
+            return unreadIncoming[0] || null;
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Вычисляет количество оставшихся непрочитанных сообщений в чате на основе прочитанного maxId.
+ * @param {Array<object>} messages
+ * @param {number} maxReadId
+ * @param {number} [totalUnreadCount]
+ * @returns {number}
+ */
+export function calculateRemainingUnreadCount(messages, maxReadId = 0, totalUnreadCount) {
+    if (!Array.isArray(messages) || messages.length === 0) return 0;
+
+    const unreadInLoaded = messages.filter((m) => !m.out && m.id > maxReadId).length;
+
+    if (typeof totalUnreadCount === "number" && totalUnreadCount > 0) {
+        const incomingInLoaded = messages.filter((m) => !m.out).length;
+        if (totalUnreadCount > incomingInLoaded) {
+            const notLoadedCount = totalUnreadCount - incomingInLoaded;
+            return notLoadedCount + unreadInLoaded;
+        }
+    }
+
+    return unreadInLoaded;
+}
+
 /**
  * Отмечает сообщения в чате прочитанными.
  * @param {import("teleproto").TelegramClient} client
@@ -279,7 +377,7 @@ export async function markAsRead(client, rawPeer, maxId = 0) {
     const entity = await resolveEntity(client, rawPeer);
     try {
         if (maxId > 0) {
-            await client.sendReadAcknowledge(entity, { maxId });
+            await client.markAsRead(entity, maxId);
         } else {
             await client.markAsRead(entity);
         }
@@ -288,6 +386,68 @@ export async function markAsRead(client, rawPeer, maxId = 0) {
     }
 }
 
+/**
+ * Выбирает самую крупную растровую миниатюру документа.
+ * PhotoPathSize (SVG-контур) и PhotoStrippedSize непригодны для полноэкранного показа.
+ * @param {Array<object>} thumbs
+ * @returns {object|null}
+ */
+function pickLargestThumb(thumbs) {
+    if (!Array.isArray(thumbs) || thumbs.length === 0) return null;
+
+    const weight = (t) => {
+        if (typeof t?.size === "number") return t.size;
+        if (Array.isArray(t?.sizes) && t.sizes.length > 0) return Math.max(...t.sizes);
+        return 0;
+    };
+
+    const usable = thumbs.filter((t) => t?.className !== "PhotoPathSize" && weight(t) > 0);
+    if (usable.length === 0) return null;
+
+    return usable.reduce((best, t) => (weight(t) > weight(best) ? t : best), usable[0]);
+}
+
+/**
+ * Загружает изображение сообщения в максимальном доступном качестве — для просмотра
+ * на весь экран.
+ *
+ * Фото качается оригиналом. У документа (видео, gif, файл) качается только самая
+ * крупная миниатюра: сам файл может весить сотни мегабайт и всё равно не рисуется.
+ *
+ * @param {import("teleproto").TelegramClient} client
+ * @param {object} rawMessage
+ * @returns {Promise<{ buffer: Buffer, mimeType: string }>}
+ */
+export async function downloadImageBuffer(client, rawMessage) {
+    const media = rawMessage?.media;
+    if (!media) {
+        throw new Error("У сообщения нет изображения.");
+    }
+
+    if (media.className === "MessageMediaPhoto") {
+        // Без thumb teleproto отдаёт самый большой размер фотографии
+        const buffer = await client.downloadMedia(media, {});
+        if (!buffer || buffer.length === 0) {
+            throw new Error("Не удалось загрузить изображение.");
+        }
+        return { buffer, mimeType: "image/jpeg" };
+    }
+
+    if (media.className === "MessageMediaDocument") {
+        const thumb = pickLargestThumb(media.document?.thumbs);
+        if (!thumb) {
+            throw new Error("У вложения нет пригодной для показа миниатюры.");
+        }
+        const buffer = await client.downloadMedia(media, { thumb });
+        if (!buffer || buffer.length === 0) {
+            throw new Error("Не удалось загрузить миниатюру вложения.");
+        }
+        return { buffer, mimeType: "image/jpeg" };
+    }
+
+    throw new Error("Этот тип вложения нельзя показать как изображение.");
+}
+
 /**
  * Асинхронно загружает и декодирует превью изображения сообщения через MTProto.
  * @param {import("teleproto").TelegramClient} client
@@ -304,6 +464,9 @@ export async function loadMessageImagePreview(client, rawMessage, { maxWidth = c
     const isDoc = media.className === "MessageMediaDocument";
     if (!isPhoto && !isDoc) return "";
 
+    const cached = getCachedImagePreview(rawMessage, { maxWidth, maxHeight });
+    if (cached) return cached;
+
     const cacheKey = isPhoto
         ? `photo_full_${media.photo?.id || rawMessage.id}`
         : `doc_full_${media.document?.id || rawMessage.id}`;