@emaxe/tuigram 1.0.1 → 1.2.0

package/src/telegram/socket.js

@@ -0,0 +1,224 @@
+/**
+ * Сетевой транспорт для MTProto с поддержкой прокси (HTTP CONNECT, SOCKS5, SOCKS4).
+ */
+import http from "node:http";
+import https from "node:https";
+import net from "node:net";
+import { PromisedNetSockets } from "teleproto/extensions/PromisedNetSockets.js";
+import { SocksClient } from "socks";
+
+/**
+ * Создаёт TCP-туннель через HTTP/HTTPS прокси методом HTTP CONNECT.
+ * Поддерживает как прокси с Basic-авторизацией, так и без неё.
+ * @param {object} params
+ * @param {boolean} [params.isHttps=false] подключение к прокси-серверу по TLS
+ * @param {string} params.proxyHost адрес прокси-сервера
+ * @param {number} params.proxyPort порт прокси-сервера
+ * @param {string} params.targetHost адрес целевого сервера Telegram MTProto
+ * @param {number} params.targetPort порт целевого сервера Telegram MTProto
+ * @param {string} [params.username] логин для авторизации на прокси
+ * @param {string} [params.password] пароль для авторизации на прокси
+ * @param {number} [params.timeout=10000] таймаут установки соединения в миллисекундах
+ * @returns {Promise<import("node:net").Socket>}
+ */
+export function createHttpConnectSocket({
+    isHttps = false,
+    proxyHost,
+    proxyPort,
+    targetHost,
+    targetPort,
+    username,
+    password,
+    timeout = 10000,
+}) {
+    return new Promise((resolve, reject) => {
+        const clientModule = isHttps ? https : http;
+
+        const headers = {
+            Host: `${targetHost}:${targetPort}`,
+            "User-Agent": "TuiGram",
+            "Proxy-Connection": "Keep-Alive",
+        };
+
+        if (username || password) {
+            const auth = Buffer.from(`${username || ""}:${password || ""}`).toString("base64");
+            headers["Proxy-Authorization"] = `Basic ${auth}`;
+        }
+
+        const req = clientModule.request({
+            host: proxyHost,
+            port: proxyPort,
+            method: "CONNECT",
+            path: `${targetHost}:${targetPort}`,
+            headers,
+            timeout,
+        });
+
+        let finished = false;
+
+        const cleanup = () => {
+            req.removeAllListeners();
+        };
+
+        req.on("connect", (res, socket, head) => {
+            if (finished) return;
+            finished = true;
+            cleanup();
+
+            if (res.statusCode >= 200 && res.statusCode < 300) {
+                // Если в заголовке ответа уже были данные следующего протокола, возвращаем их в сокет
+                if (head && head.length > 0) {
+                    socket.unshift(head);
+                }
+                resolve(socket);
+            } else if (res.statusCode === 407) {
+                socket.destroy();
+                reject(new Error("Ошибка авторизации на HTTP-прокси (407 Proxy Authentication Required)"));
+            } else {
+                socket.destroy();
+                reject(new Error(`HTTP-прокси вернул код ошибки: ${res.statusCode} ${res.statusMessage || ""}`.trim()));
+            }
+        });
+
+        req.on("response", (res) => {
+            if (finished) return;
+            finished = true;
+            cleanup();
+            if (res.statusCode === 407) {
+                reject(new Error("Ошибка авторизации на HTTP-прокси (407 Proxy Authentication Required)"));
+            } else {
+                reject(new Error(`HTTP-прокси вернул код ошибки: ${res.statusCode} ${res.statusMessage || ""}`.trim()));
+            }
+        });
+
+        req.on("timeout", () => {
+            if (finished) return;
+            finished = true;
+            cleanup();
+            req.destroy(new Error(`Таймаут подключения к HTTP-прокси (${proxyHost}:${proxyPort})`));
+        });
+
+        req.on("error", (err) => {
+            if (finished) return;
+            finished = true;
+            cleanup();
+            reject(new Error(`Не удалось подключиться к HTTP-прокси (${proxyHost}:${proxyPort}): ${err.message}`));
+        });
+
+        req.end();
+    });
+}
+
+/**
+ * Расширенный сокет для teleproto с поддержкой HTTP CONNECT и SOCKS5/4 туннелирования.
+ */
+export class TuiGramNetSockets extends PromisedNetSockets {
+    /**
+     * @param {object} [proxy]
+     * @param {number} [keepAliveInterval]
+     */
+    constructor(proxy, keepAliveInterval) {
+        // Передаём undefined в базовый класс, чтобы обойти валидацию socksType для HTTP-прокси
+        super(undefined, keepAliveInterval);
+        this.proxy = proxy;
+    }
+
+    /**
+     * Устанавливает сетевое соединение с дата-центром Telegram.
+     * @param {number} port
+     * @param {string} ip
+     * @returns {Promise<this>}
+     */
+    async connect(port, ip) {
+        this.chunks = [];
+        this.headOffset = 0;
+        this.available = 0;
+        let connected = false;
+
+        if (this.proxy) {
+            const proxyType = (this.proxy.type || "").toLowerCase();
+            const host = this.proxy.host || this.proxy.ip;
+            const proxyPort = Number(this.proxy.port);
+            const timeout = (this.proxy.timeout || 10) * 1000;
+
+            if (proxyType === "socks5" || proxyType === "socks4" || this.proxy.socksType) {
+                const socksType = this.proxy.socksType || (proxyType === "socks4" ? 4 : 5);
+                const info = await SocksClient.createConnection({
+                    proxy: {
+                        host,
+                        port: proxyPort,
+                        type: socksType,
+                        userId: this.proxy.username,
+                        password: this.proxy.password,
+                    },
+                    command: "connect",
+                    timeout,
+                    destination: {
+                        host: ip,
+                        port: port,
+                    },
+                });
+                this.client = info.socket;
+                connected = true;
+            } else if (proxyType === "http" || proxyType === "https" || this.proxy.http) {
+                this.client = await createHttpConnectSocket({
+                    isHttps: proxyType === "https",
+                    proxyHost: host,
+                    proxyPort: proxyPort,
+                    targetHost: ip,
+                    targetPort: port,
+                    username: this.proxy.username,
+                    password: this.proxy.password,
+                    timeout,
+                });
+                connected = true;
+            } else {
+                throw new Error(`Неподдерживаемый тип прокси: ${this.proxy.type}`);
+            }
+        } else {
+            this.client = new net.Socket();
+        }
+
+        this.canRead = new Promise((resolve) => {
+            this.resolveRead = resolve;
+        });
+        this.closed = false;
+
+        return new Promise((resolve, reject) => {
+            if (!this.client) {
+                return reject(new Error("Сетевой сокет не инициализирован"));
+            }
+
+            const tune = (socket) => {
+                socket.setNoDelay(true);
+                socket.setKeepAlive(this.keepAliveInterval > 0, Math.max(0, this.keepAliveInterval));
+            };
+
+            if (connected) {
+                tune(this.client);
+                this.receive();
+                resolve(this);
+            } else {
+                this.client.connect(port, ip, () => {
+                    tune(this.client);
+                    this.receive();
+                    resolve(this);
+                });
+            }
+
+            this.client.on("error", reject);
+            this.client.on("close", () => {
+                if (this.client && this.client.destroyed) {
+                    if (this.resolveRead) {
+                        this.resolveRead(false);
+                    }
+                    this.closed = true;
+                }
+            });
+        });
+    }
+
+    toString() {
+        return "TuiGramNetSocket";
+    }
+}

package/src/ui/app.js

@@ -16,7 +16,7 @@ import { state } from "../state.js";
 import { config } from "../config.js";
 import { fetchDialogs } from "../telegram/dialogs.js";
 import { setMessagePalette } from "../telegram/formatter.js";
-import { fetchHistory, sendMessage, editMessage, deleteMessages, sendFiles, downloadMedia, sendReaction, markAsRead } from "../telegram/messages.js";
+import { fetchHistory, sendMessage, editMessage, deleteMessages, sendFiles, downloadMedia, sendReaction, markAsRead, loadMessageImagePreview } from "../telegram/messages.js";
 import { startTelegramListener } from "../telegram/listener.js";
 import { logout } from "../telegram/auth.js";
 import { ensureDir, inspectLocalFile } from "../utils/storage.js";
@@ -128,6 +128,7 @@ export async function startTui(client, me) {
                 state.setMessages(dialog.id, history.messages);
                 markAsRead(client, dialog.peerId).catch(() => {});
                 statusBar.showMessage(`Чат: ${dialog.title}`, "info");
+                fetchMissingImagePreviews(history.messages, dialog.id);
             } catch (err) {
                 statusBar.showMessage(`Ошибка загрузки: ${err.message}`, "error");
             }
@@ -157,6 +158,7 @@ export async function startTui(client, me) {
                 if (older.messages.length > 0) {
                     state.setMessages(state.activeChat.id, older.messages, true);
                     statusBar.showMessage(`Загружено ${older.messages.length} предыдущих сообщений`, "info");
+                    fetchMissingImagePreviews(older.messages, state.activeChat.id);
                 }
             } catch (err) {
                 statusBar.showMessage(`Ошибка пагинации: ${err.message}`, "error");
@@ -291,9 +293,13 @@ export async function startTui(client, me) {
         chatView.setMessages(msgs);
     });
 
-    state.on("messages_updated", ({ chatId, messages, isPrepend }) => {
+    state.on("messages_updated", ({ chatId, messages, isPrepend, isUpdate, isNewMessage }) => {
         if (state.activeChat?.id === chatId) {
-            chatView.setMessages(messages, !isPrepend);
+            // Скроллим в самый низ только если это новое сообщение или первая загрузка чата.
+            // При подгрузке старых сообщений (isPrepend) или фоновых обновлениях (isUpdate)
+            // позиция скролла сохраняется!
+            const shouldScrollToBottom = isNewMessage ? config.autoScroll : (!isPrepend && !isUpdate);
+            chatView.setMessages(messages, shouldScrollToBottom);
         }
     });
 
@@ -316,11 +322,41 @@ export async function startTui(client, me) {
         }
     });
 
+    /**
+     * Фоново догружает превью изображений для сообщений, не имевших встроенного PhotoStrippedSize.
+     * @param {Array<object>} messages
+     * @param {string} chatId
+     */
+    async function fetchMissingImagePreviews(messages, chatId) {
+        if (!config.showImages || !messages || messages.length === 0) return;
+        for (const msg of messages) {
+            if (state.activeChat?.id !== chatId) break;
+            if (msg.media && !msg.imagePreview && msg.rawMessage) {
+                const isPhoto = msg.media.className === "MessageMediaPhoto";
+                const isDoc = msg.media.className === "MessageMediaDocument";
+                if (isPhoto || isDoc) {
+                    try {
+                        const preview = await loadMessageImagePreview(client, msg.rawMessage);
+                        if (preview && state.activeChat?.id === chatId) {
+                            msg.imagePreview = preview;
+                            state.updateMessage(chatId, msg);
+                        }
+                    } catch {
+                        // Игнорируем сетевые ошибки фоновой загрузки превью
+                    }
+                }
+            }
+        }
+    }
+
     // 6. Подключение фонового слушателя MTProto событий
     listener = startTelegramListener(client);
 
     listener.on("new_message", ({ peerId, message }) => {
         state.addMessage(peerId, message);
+        if (!message.imagePreview && (message.media?.className === "MessageMediaPhoto" || message.media?.className === "MessageMediaDocument")) {
+            fetchMissingImagePreviews([message], peerId);
+        }
 
         if (state.activeChat?.id === peerId) {
             markAsRead(client, state.activeChat.peerId).catch(() => {});
@@ -465,6 +501,21 @@ export async function startTui(client, me) {
     screen.key(["tab"], () => moveFocus(1));
     screen.key(["S-tab"], () => moveFocus(-1));
 
+    screen.key(["pageup", "C-u"], () => {
+        if (!state.activeChat) return;
+        chatView.scrollBox.scroll(-10);
+        if (chatView.scrollBox.getScroll() <= 0) {
+            chatView.loadMore?.();
+        }
+        screen.render();
+    });
+
+    screen.key(["pagedown", "C-d"], () => {
+        if (!state.activeChat) return;
+        chatView.scrollBox.scroll(10);
+        screen.render();
+    });
+
     screen.key(["f1", "?"], () => {
         releaseInputs();
         helpModal.show();

package/src/ui/components/chatView.js

@@ -38,7 +38,6 @@ export function createChatView(screen, theme, { onLoadMoreHistory, onActionMenu
         bottom: 0,
         tags: true,
         scrollable: true,
-        alwaysScroll: true,
         mouse: true,
         keys: true,
         vi: true,
@@ -99,8 +98,19 @@ export function createChatView(screen, theme, { onLoadMoreHistory, onActionMenu
 
             // Текст сообщения и entities
             let bodyText = formatMessageText(msg.text, msg.entities);
-            if (msg.mediaDescription) {
-                bodyText = bodyText ? `${msg.mediaDescription}\n  ${bodyText}` : msg.mediaDescription;
+
+            // Блок медиа-вложения и превью изображения
+            let mediaBlock = "";
+            if (msg.imagePreview) {
+                mediaBlock = msg.mediaDescription
+                    ? `${msg.mediaDescription}\n${msg.imagePreview}`
+                    : msg.imagePreview;
+            } else if (msg.mediaDescription) {
+                mediaBlock = msg.mediaDescription;
+            }
+
+            if (mediaBlock) {
+                bodyText = bodyText ? `${mediaBlock}\n${bodyText}` : mediaBlock;
             }
 
             // Отступ строк текста сообщения
@@ -135,26 +145,60 @@ export function createChatView(screen, theme, { onLoadMoreHistory, onActionMenu
      */
     function setMessages(messages, autoScrollToBottom = true) {
         currentMessages = messages;
+        const prevScroll = scrollBox.getScroll();
+        const prevHeight = scrollBox.getScrollHeight();
+
         scrollBox.setContent(renderMessages(messages));
+
         if (autoScrollToBottom) {
             scrollBox.setScrollPerc(100);
+        } else {
+            // Сохраняем относительную позицию скролла: если добавились старые сообщения сверху,
+            // компенсируем сдвиг высоты ленты
+            const newHeight = scrollBox.getScrollHeight();
+            const addedLines = newHeight - prevHeight;
+            if (addedLines > 0 && prevScroll > 0) {
+                scrollBox.scrollTo(prevScroll + addedLines);
+            } else if (prevScroll > 0) {
+                scrollBox.scrollTo(prevScroll);
+            }
         }
         screen.render();
     }
 
     // Обработка прокрутки вверх для подгрузки истории
-    scrollBox.key(["pageup", "C-u"], () => {
-        scrollBox.scroll(-10);
+    function handleScrollUp(step = 10) {
+        scrollBox.scroll(-step);
         if (scrollBox.getScroll() <= 0) {
             onLoadMoreHistory?.();
         }
         screen.render();
-    });
+    }
+
+    function handleScrollDown(step = 10) {
+        scrollBox.scroll(step);
+        screen.render();
+    }
 
-    scrollBox.key(["pagedown", "C-d"], () => {
-        scrollBox.scroll(10);
+    scrollBox.key(["pageup", "C-u"], () => handleScrollUp(10));
+    scrollBox.key(["pagedown", "C-d"], () => handleScrollDown(10));
+    scrollBox.key(["up", "k"], () => handleScrollUp(2));
+    scrollBox.key(["down", "j"], () => handleScrollDown(2));
+    scrollBox.key(["home"], () => {
+        scrollBox.scrollTo(0);
+        onLoadMoreHistory?.();
         screen.render();
     });
+    scrollBox.key(["end"], () => {
+        scrollBox.setScrollPerc(100);
+        screen.render();
+    });
+
+    scrollBox.on("wheelup", () => {
+        if (scrollBox.getScroll() <= 0) {
+            onLoadMoreHistory?.();
+        }
+    });
 
     // Ctrl+M терминал шлёт как "\r" (имя клавиши "return"), поэтому меню действий
     // висит на Ctrl+A — иначе оно недостижимо.
@@ -169,6 +213,7 @@ export function createChatView(screen, theme, { onLoadMoreHistory, onActionMenu
         container,
         scrollBox,
         setMessages,
+        loadMore: () => onLoadMoreHistory?.(),
         scrollToBottom: () => {
             scrollBox.setScrollPerc(100);
             screen.render();