@emaxe/tuigram 1.0.0

package/src/state.js

@@ -0,0 +1,243 @@
+import { EventEmitter } from "node:events";
+import { filterDialogsByTab, searchDialogs } from "./telegram/dialogs.js";
+
+/**
+ * Централизованное реактивное состояние TuiGram.
+ */
+class AppState extends EventEmitter {
+    constructor() {
+        super();
+        this.me = null;
+        this.connectionStatus = "connecting"; // "connecting" | "connected" | "disconnected"
+
+        /** @type {Array<object>} */
+        this.dialogs = [];
+        this.currentFilterTab = "all"; // "all" | "users" | "groups" | "channels" | "bots" | "unread" | "archived"
+        this.searchQuery = "";
+        this.selectedDialogIndex = 0;
+
+        /** @type {object|null} */
+        this.activeChat = null;
+
+        /** @type {Map<string, Array<object>>} */
+        this.messagesByChat = new Map();
+
+        /** @type {Map<string, boolean>} */
+        this.hasMoreHistory = new Map();
+
+        /** @type {Map<string, { name: string, expiresAt: number }>} */
+        this.typingByChat = new Map();
+
+        /** Режим ответа на сообщение */
+        this.replyTarget = null;
+        /** Режим редактирования своего сообщения */
+        this.editTarget = null;
+
+        /** Индекс выбранного сообщения в ленте (для контекстного меню) */
+        this.selectedMessageIndex = -1;
+
+        /** Черновики ввода по ID чата */
+        this.draftsByChat = new Map();
+    }
+
+    /**
+     * Возвращает отфильтрованный список диалогов с учётом активной вкладки и поискового запроса.
+     * @returns {Array<object>}
+     */
+    getVisibleDialogs() {
+        const tabFiltered = filterDialogsByTab(this.dialogs, this.currentFilterTab);
+        if (!this.searchQuery) return tabFiltered;
+        return searchDialogs(tabFiltered, this.searchQuery);
+    }
+
+    /**
+     * Устанавливает список всех диалогов.
+     * @param {Array<object>} dialogs
+     */
+    setDialogs(dialogs) {
+        this.dialogs = dialogs;
+        this.emit("dialogs_updated", this.getVisibleDialogs());
+    }
+
+    /**
+     * Устанавливает статус подключения.
+     * @param {"connecting"|"connected"|"disconnected"} status
+     */
+    setConnectionStatus(status) {
+        this.connectionStatus = status;
+        this.emit("status_changed", status);
+    }
+
+    /**
+     * Переключает вкладку фильтрации диалогов.
+     * @param {"all"|"users"|"groups"|"channels"|"bots"|"unread"|"archived"} tab
+     */
+    setFilterTab(tab) {
+        this.currentFilterTab = tab;
+        this.selectedDialogIndex = 0;
+        this.emit("filter_changed", { tab, dialogs: this.getVisibleDialogs() });
+    }
+
+    /**
+     * Устанавливает строку поиска.
+     * @param {string} query
+     */
+    setSearchQuery(query) {
+        this.searchQuery = query;
+        this.selectedDialogIndex = 0;
+        this.emit("search_changed", { query, dialogs: this.getVisibleDialogs() });
+    }
+
+    /**
+     * Устанавливает активный открытый чат.
+     * @param {object} dialog
+     */
+    setActiveChat(dialog) {
+        this.activeChat = dialog;
+        this.replyTarget = null;
+        this.editTarget = null;
+        this.selectedMessageIndex = -1;
+        if (dialog) {
+            dialog.unreadCount = 0;
+            dialog.unreadMentionsCount = 0;
+        }
+        this.emit("active_chat_changed", dialog);
+    }
+
+    /**
+     * Получает список сообщений для указанного чата.
+     * @param {string} chatId
+     * @returns {Array<object>}
+     */
+    getMessages(chatId) {
+        return this.messagesByChat.get(chatId) || [];
+    }
+
+    /**
+     * Устанавливает или дополняет список сообщений для чата.
+     * @param {string} chatId
+     * @param {Array<object>} newMessages
+     * @param {boolean} [prepend=false] Если true — добавляет старые сообщения в начало
+     */
+    setMessages(chatId, newMessages, prepend = false) {
+        const existing = this.messagesByChat.get(chatId) || [];
+        let combined = [];
+
+        if (prepend) {
+            // Добавление старой истории в начало
+            const existingIds = new Set(existing.map((m) => m.id));
+            const uniqueOlder = newMessages.filter((m) => !existingIds.has(m.id));
+            combined = [...uniqueOlder, ...existing];
+        } else {
+            // Слияние новых сообщений
+            const map = new Map();
+            for (const m of existing) map.set(m.id, m);
+            for (const m of newMessages) map.set(m.id, m);
+            combined = Array.from(map.values());
+        }
+
+        // Сортировка сообщений по дате / ID (хронологически снизу вверх)
+        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 });
+    }
+
+    /**
+     * Добавляет одно входящее или отправленное сообщение.
+     * @param {string} chatId
+     * @param {object} message
+     */
+    addMessage(chatId, message) {
+        const list = this.getMessages(chatId);
+        const exists = list.some((m) => m.id === message.id);
+        if (!exists) {
+            list.push(message);
+            list.sort((a, b) => (a.date || 0) - (b.date || 0) || (a.id - b.id));
+            this.messagesByChat.set(chatId, list);
+        }
+
+        // Обновляем последнее сообщение диалога в списке чатов
+        const dialog = this.dialogs.find((d) => d.id === chatId);
+        if (dialog) {
+            dialog.lastMessage = {
+                id: message.id,
+                date: message.date,
+                text: message.text,
+                out: message.out,
+                fromId: message.fromId,
+                mediaType: message.media?.className || null,
+            };
+            dialog.date = message.date;
+            if (this.activeChat?.id !== chatId && !message.out) {
+                dialog.unreadCount = (dialog.unreadCount || 0) + 1;
+            }
+            // Перемещаем чат наверх
+            this.dialogs.sort((a, b) => {
+                if (a.pinned && !b.pinned) return -1;
+                if (!a.pinned && b.pinned) return 1;
+                return (b.date || 0) - (a.date || 0);
+            });
+            this.emit("dialogs_updated", this.getVisibleDialogs());
+        }
+
+        this.emit("messages_updated", { chatId, messages: list, isPrepend: false });
+    }
+
+    /**
+     * Обновляет изменённое сообщение.
+     * @param {string} chatId
+     * @param {object} updatedMessage
+     */
+    updateMessage(chatId, updatedMessage) {
+        const list = this.getMessages(chatId);
+        const index = list.findIndex((m) => m.id === updatedMessage.id);
+        if (index !== -1) {
+            list[index] = { ...list[index], ...updatedMessage };
+            this.emit("messages_updated", { chatId, messages: list, isPrepend: false });
+        }
+    }
+
+    /**
+     * Удаляет сообщения по их ID.
+     * @param {string} chatId
+     * @param {Array<number>} deletedIds
+     */
+    removeMessages(chatId, deletedIds) {
+        const list = this.getMessages(chatId);
+        const idSet = new Set(deletedIds);
+        const filtered = list.filter((m) => !idSet.has(m.id));
+        this.messagesByChat.set(chatId, filtered);
+        this.emit("messages_updated", { chatId, messages: filtered, isPrepend: false });
+    }
+
+    /**
+     * Устанавливает статус набора текста в чате.
+     * @param {string} chatId
+     * @param {string} userName
+     */
+    setTyping(chatId, userName) {
+        this.typingByChat.set(chatId, {
+            name: userName,
+            expiresAt: Date.now() + 5000,
+        });
+        this.emit("typing_changed", { chatId, userName });
+    }
+
+    /**
+     * Возвращает имя пользователя, который сейчас печатает в чате.
+     * @param {string} chatId
+     * @returns {string|null}
+     */
+    getTypingUser(chatId) {
+        const info = this.typingByChat.get(chatId);
+        if (!info) return null;
+        if (Date.now() > info.expiresAt) {
+            this.typingByChat.delete(chatId);
+            return null;
+        }
+        return info.name;
+    }
+}
+
+export const state = new AppState();

package/src/telegram/auth.js

@@ -0,0 +1,146 @@
+import input from "input";
+import { buildClient, readSession, saveSession, clearSession } from "./client.js";
+import { config } from "../config.js";
+import { entityCache } from "./entities.js";
+
+/**
+ * Проверяет текущий статус авторизации.
+ * @returns {Promise<{ authorized: boolean, me: object|null, client: any|null }>}
+ */
+export async function checkAuthStatus() {
+    const session = readSession();
+    if (!session) {
+        return { authorized: false, me: null, client: null };
+    }
+
+    try {
+        const client = buildClient(session);
+        await client.connect();
+        const isAuth = await client.isUserAuthorized();
+        if (isAuth) {
+            const me = await client.getMe();
+            if (me) {
+                entityCache.set(me.id, me);
+            }
+            return { authorized: true, me, client };
+        }
+        await client.disconnect().catch(() => {});
+        return { authorized: false, me: null, client: null };
+    } catch {
+        return { authorized: false, me: null, client: null };
+    }
+}
+
+/**
+ * Проверяет, что интерактивный ввод вообще возможен.
+ *
+ * Без TTY промис `input.text` не резолвится никогда: teleproto молча получает
+ * пустой код (см. свой же try/catch вокруг `authParams.phoneCode`), а процесс
+ * выходит с кодом 0, так и не авторизовавшись. Отсекаем это заранее — до
+ * `client.start`, чтобы ошибка не превратилась внутри библиотеки
+ * в невнятный AUTH_USER_CANCEL.
+ *
+ * @param {object} [callbacks] пользовательские промпты — с ними терминал не нужен
+ * @param {boolean} [isTty] состояние stdin (параметром — ради тестируемости)
+ */
+export function assertInteractiveInput(callbacks = {}, isTty = process.stdin.isTTY) {
+    const covered =
+        Boolean(callbacks.getPhoneNumber) &&
+        Boolean(callbacks.getPhoneCode) &&
+        Boolean(callbacks.getPassword);
+
+    if (covered || isTty) return;
+
+    throw new Error(
+        "Авторизация требует интерактивного терминала (stdin не подключён к TTY).\n" +
+        "  • Запустите tuigram login вручную в терминале.\n" +
+        "  • Либо перенесите готовый session.txt в директорию данных\n" +
+        `    (${config.sessionPath}) — путь показывает команда tuigram paths.`
+    );
+}
+
+/**
+ * Интерактивный CLI-процесс авторизации.
+ * @param {object} [callbacks]
+ * @param {() => Promise<string>} [callbacks.getPhoneNumber]
+ * @param {() => Promise<string>} [callbacks.getPassword]
+ * @param {() => Promise<string>} [callbacks.getPhoneCode]
+ * @param {(err: Error) => boolean} [callbacks.onError]
+ * @returns {Promise<object>} возвращает объект авторизованного пользователя
+ */
+export async function loginInteractive(callbacks = {}) {
+    config.assertCredentials();
+
+    const existing = readSession();
+    if (existing) {
+        try {
+            const client = buildClient(existing);
+            await client.connect();
+            if (await client.isUserAuthorized()) {
+                const me = await client.getMe();
+                console.log(`\nВы уже авторизованы как: ${me.firstName || ""} ${me.lastName || ""} (@${me.username || "без username"}), id=${me.id}`);
+                // Без терминала спрашивать некого: действующая сессия — рабочий
+                // результат, менять аккаунт молча мы не вправе.
+                const reLogin = process.stdin.isTTY
+                    ? await input.confirm("Хотите войти под другим аккаунтом?", { default: false })
+                    : false;
+                if (!reLogin) {
+                    await client.disconnect().catch(() => {});
+                    return me;
+                }
+            }
+            await client.disconnect().catch(() => {});
+        } catch {
+            // Сессия недействительна — продолжаем логин
+        }
+    }
+
+    // Дальше без диалога не обойтись: телефон, код из Telegram и, возможно, 2FA.
+    assertInteractiveInput(callbacks);
+
+    const client = buildClient("");
+
+    const phonePrompt = callbacks.getPhoneNumber || (async () => await input.text("Введите номер телефона (+79991234567): "));
+    const passPrompt = callbacks.getPassword || (async () => await input.password("Введите пароль двухфакторной аутентификации (2FA): "));
+    const codePrompt = callbacks.getPhoneCode || (async () => await input.text("Введите код подтверждения из Telegram: "));
+
+    await client.start({
+        phoneNumber: phonePrompt,
+        password: passPrompt,
+        phoneCode: codePrompt,
+        onError: callbacks.onError || ((err) => {
+            console.error("Ошибка входа:", err?.message || err);
+            return true;
+        }),
+    });
+
+    const sessionString = client.session.save();
+    saveSession(sessionString);
+
+    const me = await client.getMe();
+    if (me) {
+        entityCache.set(me.id, me);
+    }
+
+    console.log(`\nУспешный вход! ${me.firstName || ""} ${me.lastName || ""} (@${me.username || "нет"}), ID: ${me.id}`);
+    console.log(`Сессия сохранена в ${config.sessionPath}`);
+
+    await client.disconnect().catch(() => {});
+    return me;
+}
+
+/**
+ * Завершает сеанс и удаляет локальную сессию.
+ * @param {import("teleproto").TelegramClient} [client]
+ */
+export async function logout(client) {
+    if (client) {
+        try {
+            await client.logOut();
+        } catch {
+            // Игнорируем сетевые ошибки логаута
+        }
+        await client.disconnect().catch(() => {});
+    }
+    clearSession();
+}

package/src/telegram/client.js

@@ -0,0 +1,96 @@
+import fs from "node:fs";
+import { TelegramClient } from "teleproto";
+import { StringSession } from "teleproto/sessions/index.js";
+import { Logger, LogLevel } from "teleproto/extensions/Logger.js";
+import { config } from "../config.js";
+import { saveSessionFile, readFileSafe } from "../utils/storage.js";
+
+/**
+ * Читает сохранённую строку сессии.
+ * @returns {string}
+ */
+export function readSession() {
+    return readFileSafe(config.sessionPath, "").trim();
+}
+
+/**
+ * Сохраняет строку сессии.
+ * @param {string} sessionString 
+ */
+export function saveSession(sessionString) {
+    saveSessionFile(config.sessionPath, sessionString);
+}
+
+/**
+ * Удаляет файл локальной сессии.
+ */
+export function clearSession() {
+    if (fs.existsSync(config.sessionPath)) {
+        try {
+            fs.unlinkSync(config.sessionPath);
+        } catch {
+            // Игнорируем ошибку удаления
+        }
+    }
+}
+
+/**
+ * Создаёт экземпляр клиента MTProto.
+ * @param {string} [sessionString] 
+ * @returns {TelegramClient}
+ */
+export function buildClient(sessionString = readSession()) {
+    config.assertCredentials();
+
+    const client = new TelegramClient(
+        new StringSession(sessionString),
+        config.apiId,
+        config.apiHash,
+        {
+            connectionRetries: 10,
+            autoReconnect: true,
+            retryDelay: 1500,
+            baseLogger: new Logger(LogLevel.ERROR),
+            useWSS: false,
+        }
+    );
+
+    return client;
+}
+
+/**
+ * Подключает и проверяет авторизацию клиента.
+ * @returns {Promise<TelegramClient>}
+ */
+export async function connectClient() {
+    const session = readSession();
+    if (!session) {
+        throw new Error("Сессия не найдена. Требуется авторизация: запустите логин.");
+    }
+
+    const client = buildClient(session);
+    await client.connect();
+
+    const isAuth = await client.isUserAuthorized();
+    if (!isAuth) {
+        throw new Error("Сессия недействительна или была отозвана. Требуется повторный логин.");
+    }
+
+    return client;
+}
+
+/**
+ * Выполняет действие с клиентом и корректно закрывает соединение после.
+ * @template T
+ * @param {(client: TelegramClient) => Promise<T>} fn 
+ * @returns {Promise<T>}
+ */
+export async function withClient(fn) {
+    const client = await connectClient();
+    try {
+        return await fn(client);
+    } finally {
+        await client.disconnect().catch(() => {});
+        await client.destroy?.().catch(() => {});
+    }
+}

package/src/telegram/dialogs.js

@@ -0,0 +1,130 @@
+import { idToString, toMarkedId, detectChatType, getEntityDisplayName, entityCache } from "./entities.js";
+import { describeMedia } from "./formatter.js";
+
+/**
+ * Преобразует объект Dialog из библиотеки в плоскую структуру для UI.
+ * @param {object} dialog
+ * @returns {object}
+ */
+export function normalizeDialog(dialog) {
+    const entity = dialog.entity || {};
+    const message = dialog.message;
+    const type = detectChatType(dialog);
+    const title = getEntityDisplayName(entity) || dialog.title || dialog.name || "Чат";
+
+    if (entity.id) {
+        entityCache.set(entity.id, entity);
+    }
+
+    let lastMessageText = "";
+    if (message) {
+        if (message.message) {
+            lastMessageText = message.message;
+        } else if (message.media) {
+            // Срезаем разметку blessed: цвета теперь hex, поэтому "#" обязателен
+            // в классе символов, иначе превью показывало литеральное "{#e0af68-fg}"
+            lastMessageText = describeMedia(message.media).replace(/\{\/?[#\w-]+\}/g, "");
+        }
+    }
+
+    return {
+        id: toMarkedId(dialog.id),
+        peerId: dialog.id,
+        type,
+        title,
+        username: entity.username || null,
+        pinned: Boolean(dialog.pinned),
+        archived: Boolean(dialog.archived),
+        unreadCount: dialog.unreadCount || 0,
+        unreadMentionsCount: dialog.unreadMentionsCount || 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),
+        lastMessage: message ? {
+            id: message.id,
+            date: message.date ? message.date * 1000 : Date.now(),
+            text: lastMessageText,
+            out: Boolean(message.out),
+            fromId: idToString(message.fromId?.userId || message.fromId?.channelId || message.fromId?.chatId),
+            mediaType: message.media?.className || null,
+        } : null,
+        entity,
+        rawDialog: dialog,
+    };
+}
+
+/**
+ * Загружает список всех диалогов пользователя.
+ * @param {import("teleproto").TelegramClient} client
+ * @param {object} [options]
+ * @param {number} [options.limit=100]
+ * @param {boolean} [options.archived]
+ * @returns {Promise<Array<object>>}
+ */
+export async function fetchDialogs(client, { limit = 100, archived } = {}) {
+    const params = { limit };
+    if (typeof archived === "boolean") {
+        params.archived = archived;
+    }
+
+    const dialogs = [];
+    for await (const dialog of client.iterDialogs(params)) {
+        dialogs.push(normalizeDialog(dialog));
+    }
+
+    // Сортировка: сначала закреплённые, затем по дате последнего сообщения
+    dialogs.sort((a, b) => {
+        if (a.pinned && !b.pinned) return -1;
+        if (!a.pinned && b.pinned) return 1;
+        return (b.date || 0) - (a.date || 0);
+    });
+
+    return dialogs;
+}
+
+/**
+ * Фильтрует список диалогов по выбранной категории.
+ * @param {Array<object>} dialogs
+ * @param {"all"|"users"|"groups"|"channels"|"bots"|"unread"|"archived"} filterTab
+ * @returns {Array<object>}
+ */
+export function filterDialogsByTab(dialogs, filterTab = "all") {
+    if (!dialogs) return [];
+
+    switch (filterTab) {
+        case "users":
+            return dialogs.filter((d) => !d.archived && (d.type === "user" || d.type === "saved"));
+        case "groups":
+            return dialogs.filter((d) => !d.archived && (d.type === "group" || d.type === "supergroup"));
+        case "channels":
+            return dialogs.filter((d) => !d.archived && d.type === "channel");
+        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));
+        case "archived":
+            return dialogs.filter((d) => d.archived);
+        case "all":
+        default:
+            return dialogs.filter((d) => !d.archived);
+    }
+}
+
+/**
+ * Выполняет поиск по списку диалогов по строке запроса.
+ * @param {Array<object>} dialogs
+ * @param {string} query
+ * @returns {Array<object>}
+ */
+export function searchDialogs(dialogs, query) {
+    if (!query || !query.trim()) return dialogs;
+    const q = query.trim().toLowerCase();
+
+    return dialogs.filter((d) => {
+        const titleMatch = d.title && d.title.toLowerCase().includes(q);
+        const usernameMatch = d.username && d.username.toLowerCase().includes(q);
+        const idMatch = d.id && d.id.includes(q);
+        const lastMsgMatch = d.lastMessage?.text && d.lastMessage.text.toLowerCase().includes(q);
+        return titleMatch || usernameMatch || idMatch || lastMsgMatch;
+    });
+}