@emaxe/tuigram 1.0.0

package/src/ui/app.js

@@ -0,0 +1,534 @@
+import path from "node:path";
+import fs from "node:fs";
+import { createScreen } from "./screen.js";
+import { getTheme } from "./theme.js";
+import { createHeader } from "./components/header.js";
+import { createChatList } from "./components/chatList.js";
+import { createChatView } from "./components/chatView.js";
+import { createInputBox } from "./components/inputBox.js";
+import { createStatusBar } from "./components/statusBar.js";
+import { createHelpModal } from "./components/modals/helpModal.js";
+import { createChatInfoModal } from "./components/modals/chatInfoModal.js";
+import { createActionModal } from "./components/modals/actionModal.js";
+import { createFileModal } from "./components/modals/fileModal.js";
+import { createConfirmModal } from "./components/modals/confirmModal.js";
+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 { startTelegramListener } from "../telegram/listener.js";
+import { logout } from "../telegram/auth.js";
+import { ensureDir, inspectLocalFile } from "../utils/storage.js";
+import { formatFileSize } from "../utils/time.js";
+import { parseSendFileArgs } from "../utils/commands.js";
+
+/**
+ * Запускает полноэкранный TUI-клиент Telegram.
+ * @param {import("teleproto").TelegramClient} client
+ * @param {object} me
+ */
+export async function startTui(client, me) {
+    const theme = getTheme(config.theme);
+    // Разметка сообщений и медиа-плашки красятся той же темой
+    setMessagePalette(theme);
+    /** @type {{ stop: () => void }|null} */
+    let listener = null;
+    const screen = createScreen({
+        theme,
+        onExit: () => listener?.stop(),
+    });
+
+    state.me = me;
+    state.setConnectionStatus("connected");
+
+    // 1. Создание визуальных компонентов
+    const header = createHeader(screen, theme);
+    const statusBar = createStatusBar(screen, theme);
+
+    // Модальные окна
+    const helpModal = createHelpModal(screen, theme);
+    const chatInfoModal = createChatInfoModal(screen, theme);
+    const confirmModal = createConfirmModal(screen, theme);
+    const fileModal = createFileModal(screen, theme, {
+        onSendFile: (files, options) => sendFilesToActiveChat(files, options),
+    });
+
+    const actionModal = createActionModal(screen, theme, {
+        onAction: async (actionId, msg) => {
+            if (!state.activeChat) return;
+            const peerId = state.activeChat.peerId;
+
+            switch (actionId) {
+                case "reply":
+                    inputBox.setContext("reply", msg);
+                    break;
+                case "edit":
+                    inputBox.setContext("edit", msg);
+                    break;
+                case "delete":
+                    releaseInputs();
+                    confirmModal.ask(`Удалить сообщение #${msg.id} для всех?`, async () => {
+                        try {
+                            await deleteMessages(client, peerId, [msg.id], { revoke: true });
+                            state.removeMessages(state.activeChat.id, [msg.id]);
+                            statusBar.showMessage(`Сообщение #${msg.id} удалено`, "success");
+                        } catch (err) {
+                            statusBar.showMessage(`Ошибка удаления: ${err.message}`, "error");
+                        }
+                    });
+                    break;
+                case "react_like":
+                case "react_fire":
+                case "react_heart": {
+                    const emojiMap = { react_like: "👍", react_fire: "🔥", react_heart: "❤️" };
+                    const emoji = emojiMap[actionId] || "👍";
+                    try {
+                        await sendReaction(client, peerId, msg.id, emoji);
+                        statusBar.showMessage(`Поставлена реакция ${emoji}`, "success");
+                    } catch (err) {
+                        statusBar.showMessage(`Ошибка реакции: ${err.message}`, "error");
+                    }
+                    break;
+                }
+                case "download": {
+                    try {
+                        const downloadsDir = config.downloadsDir;
+                        ensureDir(downloadsDir);
+                        const fileName = `media_${msg.id}_${Date.now()}`;
+                        const targetPath = path.join(downloadsDir, fileName);
+                        statusBar.showMessage("Скачивание медиа-вложения...", "info");
+                        const res = await downloadMedia(client, msg.rawMessage, { outputFile: targetPath });
+                        const finalPath = typeof res === "string" ? res : targetPath;
+                        statusBar.showMessage(`✓ Файл сохранён: ${finalPath}`, "success");
+                    } catch (err) {
+                        statusBar.showMessage(`Ошибка скачивания: ${err.message}`, "error");
+                    }
+                    break;
+                }
+                case "copy":
+                    if (msg.text) {
+                        inputBox.textarea.setValue(msg.text);
+                        inputBox.focus();
+                        statusBar.showMessage("Текст скопирован в поле ввода", "info");
+                    }
+                    break;
+            }
+        },
+    });
+
+    // 2. Список диалогов (левая панель)
+    const chatList = createChatList(screen, theme, {
+        onSelectDialog: async (dialog) => {
+            state.setActiveChat(dialog);
+            statusBar.showMessage(`Загрузка сообщений: ${dialog.title}...`, "info");
+
+            try {
+                const history = await fetchHistory(client, dialog.peerId, { limit: 50 });
+                state.setMessages(dialog.id, history.messages);
+                markAsRead(client, dialog.peerId).catch(() => {});
+                statusBar.showMessage(`Чат: ${dialog.title}`, "info");
+            } catch (err) {
+                statusBar.showMessage(`Ошибка загрузки: ${err.message}`, "error");
+            }
+        },
+        onTabChange: (tab) => {
+            state.setFilterTab(tab);
+        },
+        onSearchChange: (query) => {
+            state.setSearchQuery(query);
+        },
+    });
+
+    // 3. Просмотр сообщений (правая центральная панель)
+    const chatView = createChatView(screen, theme, {
+        onLoadMoreHistory: async () => {
+            if (!state.activeChat) return;
+            const current = state.getMessages(state.activeChat.id);
+            if (current.length === 0) return;
+
+            const oldestId = current[0].id;
+            try {
+                statusBar.showMessage("Подгрузка более старых сообщений...", "info");
+                const older = await fetchHistory(client, state.activeChat.peerId, {
+                    limit: 30,
+                    offsetId: oldestId,
+                });
+                if (older.messages.length > 0) {
+                    state.setMessages(state.activeChat.id, older.messages, true);
+                    statusBar.showMessage(`Загружено ${older.messages.length} предыдущих сообщений`, "info");
+                }
+            } catch (err) {
+                statusBar.showMessage(`Ошибка пагинации: ${err.message}`, "error");
+            }
+        },
+        onActionMenu: (msg) => {
+            releaseInputs();
+            actionModal.show(msg);
+        },
+    });
+
+    // 4. Поле ввода (нижняя панель)
+    const inputBox = createInputBox(screen, theme, {
+        onSubmit: async (text, context) => {
+            if (!state.activeChat) {
+                statusBar.showMessage("Сначала выберите чат слева!", "warning");
+                return;
+            }
+
+            const peerId = state.activeChat.peerId;
+
+            if (context.mode === "edit" && context.target) {
+                // Редактирование
+                try {
+                    statusBar.showMessage("Редактирование...", "info");
+                    const edited = await editMessage(client, peerId, context.target.id, text);
+                    state.updateMessage(state.activeChat.id, edited);
+                    statusBar.showMessage("✓ Сообщение изменено", "success");
+                } catch (err) {
+                    statusBar.showMessage(`Ошибка редактирования: ${err.message}`, "error");
+                }
+            } else {
+                // Отправка нового сообщения или ответа
+                try {
+                    const replyTo = context.mode === "reply" && context.target ? context.target.id : undefined;
+                    const sent = await sendMessage(client, peerId, text, { replyTo });
+                    state.addMessage(state.activeChat.id, sent);
+                    statusBar.showMessage("✓ Отправлено", "success", 2000);
+                } catch (err) {
+                    statusBar.showMessage(`Ошибка отправки: ${err.message}`, "error");
+                }
+            }
+        },
+        onCancelContext: () => {
+            statusBar.showMessage("Режим ответа/редактирования сброшен", "info", 2000);
+        },
+        onSlashCommand: (cmd, args) => {
+            switch (cmd) {
+                case "help":
+                    releaseInputs();
+                    helpModal.show();
+                    break;
+                case "info":
+                    releaseInputs();
+                    if (state.activeChat) chatInfoModal.show(state.activeChat);
+                    else statusBar.showMessage("Сначала выберите чат!", "warning");
+                    break;
+                case "sendfile": {
+                    // Формат: /sendfile путь [| путь ...] [-- подпись]
+                    const { paths, caption } = parseSendFileArgs(args);
+                    if (paths.length === 0) {
+                        releaseInputs();
+                        fileModal.show();
+                        break;
+                    }
+                    if (!state.activeChat) {
+                        statusBar.showMessage("Сначала выберите чат для отправки файла!", "warning");
+                        break;
+                    }
+
+                    const files = [];
+                    let invalid = null;
+                    for (const entry of paths) {
+                        const info = inspectLocalFile(entry);
+                        if (!info.ok) {
+                            invalid = info.error;
+                            break;
+                        }
+                        files.push(info);
+                    }
+                    if (invalid) {
+                        statusBar.showMessage(invalid, "error");
+                        break;
+                    }
+
+                    sendFilesToActiveChat(files, { caption });
+                    break;
+                }
+                case "clear":
+                    if (state.activeChat) {
+                        state.messagesByChat.set(state.activeChat.id, []);
+                        chatView.setMessages([]);
+                        statusBar.showMessage("Лента очищена на экране", "info");
+                    }
+                    break;
+                case "logout":
+                    releaseInputs();
+                    confirmModal.ask("Вы действительно хотите выйти из аккаунта?", async () => {
+                        await logout(client);
+                        screen.destroy();
+                        console.log("\nВы успешно вышли из аккаунта.");
+                        process.exit(0);
+                    });
+                    break;
+                default:
+                    statusBar.showMessage(`Неизвестная команда: /${cmd}. Введите /help для справки.`, "warning");
+            }
+        },
+    });
+
+    // 5. Реакция на события состояния
+    state.on("dialogs_updated", (dialogs) => {
+        chatList.setDialogs(dialogs);
+    });
+
+    state.on("filter_changed", ({ dialogs }) => {
+        chatList.setDialogs(dialogs);
+    });
+
+    state.on("search_changed", ({ dialogs }) => {
+        chatList.setDialogs(dialogs);
+    });
+
+    state.on("active_chat_changed", (chat) => {
+        header.updateInfo({
+            me: state.me,
+            status: state.connectionStatus,
+            activeChat: chat,
+            typingUser: state.getTypingUser(chat?.id),
+        });
+        const msgs = chat ? state.getMessages(chat.id) : [];
+        chatView.setMessages(msgs);
+    });
+
+    state.on("messages_updated", ({ chatId, messages, isPrepend }) => {
+        if (state.activeChat?.id === chatId) {
+            chatView.setMessages(messages, !isPrepend);
+        }
+    });
+
+    state.on("typing_changed", ({ chatId, userName }) => {
+        if (state.activeChat?.id === chatId) {
+            header.updateInfo({
+                me: state.me,
+                status: state.connectionStatus,
+                activeChat: state.activeChat,
+                typingUser: userName,
+            });
+            setTimeout(() => {
+                header.updateInfo({
+                    me: state.me,
+                    status: state.connectionStatus,
+                    activeChat: state.activeChat,
+                    typingUser: state.getTypingUser(chatId),
+                });
+            }, 5000);
+        }
+    });
+
+    // 6. Подключение фонового слушателя MTProto событий
+    listener = startTelegramListener(client);
+
+    listener.on("new_message", ({ peerId, message }) => {
+        state.addMessage(peerId, message);
+
+        if (state.activeChat?.id === peerId) {
+            markAsRead(client, state.activeChat.peerId).catch(() => {});
+        } else if (!message.out) {
+            const sender = message.senderName || "Новое сообщение";
+            const preview = (message.text || "Вложение").slice(0, 30);
+            statusBar.showMessage(`💬 ${sender}: "${preview}"`, "info", 5000);
+        }
+    });
+
+    listener.on("edited_message", ({ peerId, message }) => {
+        state.updateMessage(peerId, message);
+    });
+
+    listener.on("deleted_messages", ({ peerId, deletedIds }) => {
+        state.removeMessages(peerId, deletedIds);
+    });
+
+    listener.on("typing", ({ chatId, userId }) => {
+        state.setTyping(chatId, "Собеседник");
+    });
+
+    /**
+     * Единая точка отправки файлов: прогресс, отмена по Esc, режим «Ответ».
+     * @param {Array<{filePath: string, name: string, size: number}>} files
+     * @param {object} [options]
+     * @param {string} [options.caption]
+     * @param {boolean} [options.asDocument]
+     */
+    async function sendFilesToActiveChat(files, { caption = "", asDocument = false } = {}) {
+        if (!state.activeChat) {
+            statusBar.showMessage("Сначала выберите чат для отправки файла!", "warning");
+            return;
+        }
+        if (!files || files.length === 0) return;
+
+        const chat = state.activeChat;
+        const label = files.length === 1
+            ? files[0].name
+            : `${files.length} файлов`;
+        const totalSize = files.reduce((sum, f) => sum + (f.size || 0), 0);
+
+        // Файл отправляется ответом, если активен режим Reply
+        const ctx = inputBox.getContext?.() ?? { mode: null, target: null };
+        const replyTo = ctx.mode === "reply" && ctx.target ? ctx.target.id : undefined;
+
+        // Прогресс 0..1 от teleproto; троттлим по целым процентам и по времени
+        let lastPercent = -1;
+        let lastTick = 0;
+        const progressCallback = (progress) => {
+            const percent = Math.min(99, Math.round((progress || 0) * 100));
+            const now = Date.now();
+            if (percent === lastPercent || now - lastTick < 200) return;
+            lastPercent = percent;
+            lastTick = now;
+            statusBar.showMessage(
+                `Отправка ${label}: ${percent}% (${formatFileSize(totalSize)}) · [Esc] отменить`,
+                "info",
+                60000
+            );
+        };
+
+        // teleproto проверяет isCanceled между чанками и бросает USER_CANCELED
+        const cancel = () => {
+            progressCallback.isCanceled = true;
+            statusBar.showMessage("Отмена отправки...", "warning", 3000);
+        };
+        screen.key(["escape"], cancel);
+
+        try {
+            statusBar.showMessage(`Отправка ${label} (${formatFileSize(totalSize)})...`, "info", 60000);
+            const sent = await sendFiles(
+                client,
+                chat.peerId,
+                files.map((f) => f.filePath),
+                { caption, replyTo, forceDocument: asDocument, progressCallback }
+            );
+            for (const msg of sent) {
+                state.addMessage(chat.id, msg);
+            }
+            if (replyTo) inputBox.clearContext();
+            statusBar.showMessage(`✓ Отправлено: ${label}`, "success");
+        } catch (err) {
+            const message = /USER_CANCELED/i.test(err?.message || "")
+                ? `Отправка ${label} отменена`
+                : `Ошибка отправки файла: ${err.message}`;
+            statusBar.showMessage(message, /USER_CANCELED/i.test(err?.message || "") ? "warning" : "error");
+        } finally {
+            screen.unkey(["escape"], cancel);
+        }
+    }
+
+    /**
+     * Освобождает клавиатуру перед открытием модального окна.
+     * blessed-поля ввода (textarea/textbox) держат screen.grabKeys и по blur
+     * возвращают себе фокус — без этого модалка открывается «мёртвой».
+     */
+    function releaseInputs() {
+        inputBox.release?.();
+        chatList.release?.();
+    }
+
+    // 7. Глобальные сочетания клавиш
+    // Цикл фокуса: список чатов -> лента сообщений -> поле ввода -> список чатов.
+    // Без ленты в цикле были недостижимы прокрутка, подгрузка истории и меню действий.
+    const FOCUS_ORDER = ["chatList", "chatView", "input"];
+    const FOCUS_TARGETS = {
+        chatList: chatList,
+        chatView: chatView,
+        input: inputBox,
+    };
+
+    /**
+     * Определяет текущую панель по реальному фокусу blessed.
+     * Нужно потому, что textarea по Escape сама вызывает screen.rewindFocus().
+     * @returns {"chatList"|"chatView"|"input"}
+     */
+    function detectFocus() {
+        const el = screen.focused;
+        if (el === inputBox.textarea) return "input";
+        if (el === chatView.scrollBox) return "chatView";
+        return "chatList";
+    }
+
+    function moveFocus(step) {
+        const current = FOCUS_ORDER.indexOf(detectFocus());
+        const next = FOCUS_ORDER[(current + step + FOCUS_ORDER.length) % FOCUS_ORDER.length];
+        // Сначала выпускаем клавиатуру из активного поля ввода, иначе оно
+        // заберёт фокус обратно своим обработчиком blur.
+        releaseInputs();
+        FOCUS_TARGETS[next].focus();
+        statusBar.showMessage(
+            next === "chatList" ? "Фокус: список чатов" :
+            next === "chatView" ? "Фокус: лента сообщений (PageUp/PageDown, Ctrl+A — действия)" :
+            "Фокус: поле ввода",
+            "info",
+            2000
+        );
+        screen.render();
+    }
+
+    screen.key(["tab"], () => moveFocus(1));
+    screen.key(["S-tab"], () => moveFocus(-1));
+
+    screen.key(["f1", "?"], () => {
+        releaseInputs();
+        helpModal.show();
+    });
+
+    // Ctrl+I терминал шлёт как таб ("\t"), поэтому информация о чате — на Ctrl+P.
+    screen.key(["C-p"], () => {
+        if (state.activeChat) {
+            releaseInputs();
+            chatInfoModal.show(state.activeChat);
+        } else {
+            statusBar.showMessage("Сначала выберите чат слева!", "warning");
+        }
+    });
+
+    screen.key(["C-o"], () => {
+        if (state.activeChat) {
+            releaseInputs();
+            fileModal.show();
+        } else {
+            statusBar.showMessage("Сначала выберите чат слева!", "warning");
+        }
+    });
+
+    screen.key(["C-r"], () => {
+        if (!state.activeChat) return;
+        const msgs = state.getMessages(state.activeChat.id);
+        if (msgs.length > 0) {
+            const lastMsg = msgs[msgs.length - 1];
+            inputBox.setContext("reply", lastMsg);
+        }
+    });
+
+    screen.key(["C-e"], () => {
+        if (!state.activeChat) return;
+        const msgs = state.getMessages(state.activeChat.id);
+        const ownMsgs = msgs.filter((m) => m.out);
+        if (ownMsgs.length > 0) {
+            const lastOwn = ownMsgs[ownMsgs.length - 1];
+            inputBox.setContext("edit", lastOwn);
+        }
+    });
+
+    screen.key(["C-q"], () => {
+        releaseInputs();
+        confirmModal.ask("Выйти из TuiGram?", () => {
+            listener?.stop();
+            screen.destroy();
+            process.exit(0);
+        });
+    });
+
+    // 8. Первоначальная загрузка диалогов
+    header.updateInfo({ me, status: "connected", activeChat: null });
+    statusBar.showMessage("Загрузка списка диалогов...", "info");
+    chatList.focus();
+
+    try {
+        const dialogs = await fetchDialogs(client, { limit: 100 });
+        state.setDialogs(dialogs);
+        statusBar.showMessage(`Загружено ${dialogs.length} диалогов. Выберите чат и нажмите Enter.`, "success");
+    } catch (err) {
+        statusBar.showMessage(`Ошибка загрузки диалогов: ${err.message}`, "error");
+    }
+
+    screen.render();
+}