@emaxe/tuigram 1.0.0

package/src/telegram/entities.js

@@ -0,0 +1,158 @@
+/**
+ * Резолвинг пиров, типов сущностей и безопасная работа с ID Telegram.
+ */
+import { getPeerId } from "teleproto/Utils.js";
+
+/**
+ * Приводит идентификатор Telegram к строковому представлению.
+ * @param {unknown} value
+ * @returns {string}
+ */
+export function idToString(value) {
+    if (value === null || value === undefined) return "";
+    if (typeof value === "bigint" || typeof value === "number") return value.toString();
+    if (typeof value === "string") return value;
+    if (value && typeof value === "object") {
+        if (typeof value.value !== "undefined") return idToString(value.value);
+        if (typeof value.userId !== "undefined") return idToString(value.userId);
+        if (typeof value.channelId !== "undefined") return idToString(value.channelId);
+        if (typeof value.chatId !== "undefined") return idToString(value.chatId);
+        if (typeof value.toString === "function") return value.toString();
+    }
+    return String(value);
+}
+
+/**
+ * Приводит пир (Peer* из MTProto, сущность или готовый ID) к "маркированному"
+ * строковому ID в том же формате, в каком его отдаёт teleproto для диалогов:
+ * пользователь -> "123", группа -> "-456", канал/супергруппа -> "-100789".
+ *
+ * Без этого ID сообщения (немаркированный channelId) не совпадает с ID диалога
+ * и входящие сообщения групп/каналов не попадают в открытый чат.
+ * @param {unknown} peer
+ * @returns {string}
+ */
+export function toMarkedId(peer) {
+    if (peer === null || peer === undefined) return "";
+    try {
+        const id = getPeerId(peer);
+        if (id !== null && id !== undefined && id !== "") return String(id);
+    } catch {
+        // Не Peer-объект — падаем на обычное строковое представление
+    }
+    return idToString(peer);
+}
+
+/**
+ * Преобразует пользовательский ввод в формат, понятный MTProto.
+ * @param {string|number|bigint} raw "@username" | "username" | "-1001234567890" | "me"
+ * @returns {string|bigint}
+ */
+export function parsePeer(raw) {
+    const value = String(raw || "").trim();
+    if (!value) throw new Error("Не указан идентификатор чата (peer)");
+    if (value === "me" || value === "self") return "me";
+    if (/^-?\d+$/.test(value)) {
+        return BigInt(value);
+    }
+    return value.startsWith("@") ? value : `@${value}`;
+}
+
+/**
+ * Определяет тип диалога.
+ * @param {object} dialog
+ * @returns {"user"|"bot"|"group"|"supergroup"|"channel"|"saved"|"unknown"}
+ */
+export function detectChatType(dialog) {
+    if (!dialog) return "unknown";
+    if (dialog.id === "me" || dialog.isSelf) return "saved";
+    const entity = dialog.entity || {};
+    if (dialog.isUser || entity.className === "User") {
+        if (entity.isSelf) return "saved";
+        return entity.bot ? "bot" : "user";
+    }
+    if (dialog.isChannel || entity.className === "Channel") {
+        return entity.broadcast ? "channel" : "supergroup";
+    }
+    if (dialog.isGroup || entity.className === "Chat") {
+        return entity.megagroup ? "supergroup" : "group";
+    }
+    return "unknown";
+}
+
+/**
+ * Возвращает отображаемое имя для сущности (пользователя, канала или чата).
+ * @param {object} entity
+ * @returns {string}
+ */
+export function getEntityDisplayName(entity) {
+    if (!entity) return "Неизвестный чат";
+    if (entity.isSelf) return "Избранное (Saved Messages)";
+    if (entity.title) return entity.title;
+    const parts = [entity.firstName, entity.lastName].filter(Boolean);
+    if (parts.length > 0) return parts.join(" ");
+    if (entity.username) return `@${entity.username}`;
+    if (entity.id) return `Чат ${idToString(entity.id)}`;
+    return "Без названия";
+}
+
+/**
+ * Кэш сущностей (пользователи, каналы, чаты) для быстрого доступа.
+ */
+class EntityCache {
+    constructor() {
+        /** @type {Map<string, object>} */
+        this.cache = new Map();
+    }
+
+    set(id, entity) {
+        if (!id || !entity) return;
+        const key = idToString(id);
+        this.cache.set(key, entity);
+        if (entity.username) {
+            this.cache.set(`@${entity.username.toLowerCase()}`, entity);
+        }
+    }
+
+    get(idOrUsername) {
+        if (!idOrUsername) return null;
+        const key = String(idOrUsername).toLowerCase();
+        return this.cache.get(key) || this.cache.get(idToString(idOrUsername)) || null;
+    }
+
+    has(idOrUsername) {
+        return this.get(idOrUsername) !== null;
+    }
+
+    clear() {
+        this.cache.clear();
+    }
+}
+
+export const entityCache = new EntityCache();
+
+/**
+ * Разрешает сущность чата по строковому представлению с обработкой частых ошибок.
+ * @param {import("teleproto").TelegramClient} client
+ * @param {string|number|bigint} rawPeer
+ * @returns {Promise<object>}
+ */
+export async function resolveEntity(client, rawPeer) {
+    const peer = parsePeer(rawPeer);
+    try {
+        const entity = await client.getEntity(peer);
+        if (entity) {
+            entityCache.set(entity.id, entity);
+        }
+        return entity;
+    } catch (err) {
+        const msg = err?.message || String(err);
+        if (/CHANNEL_PRIVATE/i.test(msg)) {
+            throw new Error(`Нет доступа к ${rawPeer}: канал приватный или аккаунт в нём не состоит.`);
+        }
+        if (/USERNAME_NOT_OCCUPIED|USERNAME_INVALID|Cannot find any entity/i.test(msg)) {
+            throw new Error(`Чат ${rawPeer} не найден. Проверьте правильность username или ID.`);
+        }
+        throw err;
+    }
+}

package/src/telegram/formatter.js

@@ -0,0 +1,248 @@
+import { formatFileSize, formatDuration } from "../utils/time.js";
+
+/**
+ * Палитра для разметки сообщений и медиа-плашек.
+ *
+ * Значения по умолчанию рассчитаны на тёмный фон и заданы hex-ом: именованные
+ * цвета терминала (особенно "blue" и "gray") на тёмном фоне почти не читаются.
+ * TUI подменяет палитру активной темой через setMessagePalette().
+ */
+const colors = {
+    code: "#e0af68",
+    codeBg: "#1f2335",
+    pre: "#e0af68",
+    link: "#7dcfff",
+    url: "#7aa2f7",
+    mention: "#bb9af7",
+    hashtag: "#7aa2f7",
+    spoiler: "#565f89",
+    photo: "#e0af68",
+    voice: "#7dcfff",
+    audio: "#9ece6a",
+    video: "#bb9af7",
+    sticker: "#e0af68",
+    document: "#7aa2f7",
+    poll: "#bb9af7",
+    geo: "#9ece6a",
+    contact: "#7dcfff",
+    venue: "#9ece6a",
+    dice: "#e0af68",
+    webpage: "#7dcfff",
+    unknown: "#565f89",
+};
+
+/**
+ * Подменяет палитру разметки цветами активной темы.
+ * @param {object} theme
+ */
+export function setMessagePalette(theme) {
+    if (!theme) return;
+    Object.assign(colors, {
+        code: theme.warning,
+        codeBg: theme.surfaceHigh,
+        pre: theme.warning,
+        link: theme.info,
+        url: theme.accent,
+        mention: theme.chatView.mediaFg,
+        hashtag: theme.accent,
+        spoiler: theme.dim,
+        photo: theme.warning,
+        voice: theme.info,
+        audio: theme.success,
+        video: theme.chatView.mediaFg,
+        sticker: theme.warning,
+        document: theme.accent,
+        poll: theme.chatView.mediaFg,
+        geo: theme.success,
+        contact: theme.info,
+        venue: theme.success,
+        dice: theme.warning,
+        webpage: theme.info,
+        unknown: theme.dim,
+    });
+}
+
+/**
+ * Экранирует спецсимволы тегов blessed в обычном тексте сообщений,
+ * чтобы фигурные скобки { ... } в коде или тексте пользователя не ломали рендер.
+ * @param {string} text
+ * @returns {string}
+ */
+export function escapeBlessed(text) {
+    if (!text) return "";
+    return String(text).replace(/\{/g, "\\{").replace(/\}/g, "\\}");
+}
+
+/**
+ * Преобразует разметку сообщения Telegram (entities) в форматированный Blessed-текст.
+ * @param {string} rawText 
+ * @param {Array<object>} [entities=[]]
+ * @returns {string}
+ */
+export function formatMessageText(rawText, entities = []) {
+    if (!rawText) return "";
+    if (!entities || entities.length === 0) {
+        return escapeBlessed(rawText);
+    }
+
+    // Сортируем entities по смещению от начала к концу
+    const sorted = [...entities].sort((a, b) => (a.offset || 0) - (b.offset || 0));
+
+    let result = "";
+    let currentIndex = 0;
+
+    for (const entity of sorted) {
+        const offset = entity.offset || 0;
+        const length = entity.length || 0;
+        if (offset < currentIndex || offset > rawText.length) continue;
+
+        // Неформатированный фрагмент до текущего entity
+        if (offset > currentIndex) {
+            result += escapeBlessed(rawText.slice(currentIndex, offset));
+        }
+
+        const fragment = rawText.slice(offset, offset + length);
+        const escaped = escapeBlessed(fragment);
+        const className = entity.className || "";
+
+        switch (className) {
+            case "MessageEntityBold":
+                result += `{bold}${escaped}{/bold}`;
+                break;
+            case "MessageEntityItalic":
+                result += `{|}${escaped}{/|}`;
+                break;
+            case "MessageEntityCode":
+                result += `{${colors.code}-fg}{${colors.codeBg}-bg}${escaped}{/${colors.codeBg}-bg}{/${colors.code}-fg}`;
+                break;
+            case "MessageEntityPre":
+                result += `{${colors.pre}-fg}\n${escaped}\n{/${colors.pre}-fg}`;
+                break;
+            case "MessageEntityTextUrl":
+                result += `{${colors.link}-fg}{underline}${escaped}{/underline}{/${colors.link}-fg} ({${colors.url}-fg}${escapeBlessed(entity.url || "")}{/${colors.url}-fg})`;
+                break;
+            case "MessageEntityUrl":
+                result += `{${colors.link}-fg}{underline}${escaped}{/underline}{/${colors.link}-fg}`;
+                break;
+            case "MessageEntityMention":
+            case "MessageEntityMentionName":
+                result += `{${colors.mention}-fg}${escaped}{/${colors.mention}-fg}`;
+                break;
+            case "MessageEntityHashtag":
+                result += `{${colors.hashtag}-fg}${escaped}{/${colors.hashtag}-fg}`;
+                break;
+            case "MessageEntityStrike":
+                result += `{${colors.spoiler}-fg}${escaped}{/${colors.spoiler}-fg}`;
+                break;
+            case "MessageEntityUnderline":
+                result += `{underline}${escaped}{/underline}`;
+                break;
+            case "MessageEntitySpoiler":
+                result += `{inverse}${escaped}{/inverse}`;
+                break;
+            default:
+                result += escaped;
+        }
+
+        currentIndex = offset + length;
+    }
+
+    if (currentIndex < rawText.length) {
+        result += escapeBlessed(rawText.slice(currentIndex));
+    }
+
+    return result;
+}
+
+/**
+ * Возвращает краткое описание медиа-вложения для сообщения.
+ * @param {object} media
+ * @returns {string}
+ */
+export function describeMedia(media) {
+    if (!media) return "";
+    const type = media.className || "";
+
+    switch (type) {
+        case "MessageMediaPhoto": {
+            return `{${colors.photo}-fg}[📷 Фотография]{/${colors.photo}-fg}`;
+        }
+        case "MessageMediaDocument": {
+            const doc = media.document || {};
+            const attributes = doc.attributes || [];
+            let fileName = "файл";
+            let isVoice = false;
+            let isAudio = false;
+            let isVideo = false;
+            let isSticker = false;
+            let duration = 0;
+            let performer = "";
+            let title = "";
+
+            for (const attr of attributes) {
+                if (attr.className === "DocumentAttributeFilename") {
+                    fileName = attr.fileName || fileName;
+                }
+                if (attr.className === "DocumentAttributeAudio") {
+                    if (attr.voice) isVoice = true;
+                    else isAudio = true;
+                    duration = attr.duration || 0;
+                    performer = attr.performer || "";
+                    title = attr.title || "";
+                }
+                if (attr.className === "DocumentAttributeVideo") {
+                    isVideo = true;
+                    duration = attr.duration || 0;
+                }
+                if (attr.className === "DocumentAttributeSticker") {
+                    isSticker = true;
+                    if (attr.alt) fileName = `Стикер ${attr.alt}`;
+                }
+            }
+
+            const size = formatFileSize(doc.size || 0);
+
+            if (isVoice) {
+                return `{${colors.voice}-fg}[🎤 Голосовое сообщение (${formatDuration(duration)})]{/${colors.voice}-fg}`;
+            }
+            if (isAudio) {
+                const track = [performer, title].filter(Boolean).join(" - ") || fileName;
+                return `{${colors.audio}-fg}[🎵 Аудио: ${escapeBlessed(track)} (${formatDuration(duration)}, ${size})]{/${colors.audio}-fg}`;
+            }
+            if (isVideo) {
+                return `{${colors.video}-fg}[📹 Видео (${formatDuration(duration)}, ${size})]{/${colors.video}-fg}`;
+            }
+            if (isSticker) {
+                return `{${colors.sticker}-fg}[🖼 ${escapeBlessed(fileName)}]{/${colors.sticker}-fg}`;
+            }
+            return `{${colors.document}-fg}[📄 Документ: ${escapeBlessed(fileName)} (${size})]{/${colors.document}-fg}`;
+        }
+        case "MessageMediaPoll": {
+            const poll = media.poll || {};
+            const question = poll.question?.text || poll.question || "Опрос";
+            return `{${colors.poll}-fg}[📊 Опрос: "${escapeBlessed(question)}"]{/${colors.poll}-fg}`;
+        }
+        case "MessageMediaGeo":
+        case "MessageMediaGeoLive": {
+            return `{${colors.geo}-fg}[📍 Геолокация]{/${colors.geo}-fg}`;
+        }
+        case "MessageMediaContact": {
+            const contact = media;
+            const name = [contact.firstName, contact.lastName].filter(Boolean).join(" ");
+            return `{${colors.contact}-fg}[👤 Контакт: ${escapeBlessed(name)} (${escapeBlessed(contact.phoneNumber || "")})]{/${colors.contact}-fg}`;
+        }
+        case "MessageMediaVenue": {
+            return `{${colors.venue}-fg}[🏢 Место: ${escapeBlessed(media.title || "")}]{/${colors.venue}-fg}`;
+        }
+        case "MessageMediaDice": {
+            return `{${colors.dice}-fg}[🎲 Игральная кость: ${media.value || ""} (${escapeBlessed(media.emoticon || "")})]{/${colors.dice}-fg}`;
+        }
+        case "MessageMediaWebPage": {
+            const page = media.webpage || {};
+            const title = page.title || page.displayUrl || page.url || "";
+            return title ? `{${colors.webpage}-fg}[🔗 Ссылка: ${escapeBlessed(title)}]{/${colors.webpage}-fg}` : "";
+        }
+        default:
+            return `{${colors.unknown}-fg}[Вложение: ${escapeBlessed(type)}]{/${colors.unknown}-fg}`;
+    }
+}

package/src/telegram/listener.js

@@ -0,0 +1,141 @@
+import { EventEmitter } from "node:events";
+import { Api } from "teleproto";
+import { NewMessage, EditedMessage, DeletedMessage, Raw } from "teleproto/events/index.js";
+import { normalizeMessage } from "./messages.js";
+import { idToString, toMarkedId, entityCache } from "./entities.js";
+
+/**
+ * Приводит идентификатор чата из сырого апдейта к маркированному виду (как dialog.id).
+ * @param {object} update
+ * @returns {string}
+ */
+function updateChatId(update) {
+    if (update.peer) return toMarkedId(update.peer);
+    if (update.channelId) return toMarkedId(new Api.PeerChannel({ channelId: update.channelId }));
+    if (update.chatId) return toMarkedId(new Api.PeerChat({ chatId: update.chatId }));
+    return "";
+}
+
+/**
+ * Запускает фоновое прослушивание живых событий Telegram и транслирует их в шину событий.
+ * @param {import("teleproto").TelegramClient} client
+ * @returns {EventEmitter & { stop: () => void }}
+ */
+export function startTelegramListener(client) {
+    const bus = new EventEmitter();
+    bus.setMaxListeners(0);
+
+    const handlers = [];
+    const on = (handler, event) => {
+        client.addEventHandler(handler, event);
+        handlers.push(handler);
+    };
+
+    // 1. Новые сообщения
+    on(async (event) => {
+        try {
+            const msg = event.message;
+            if (!msg) return;
+            const normalized = normalizeMessage(msg);
+            const peerId = normalized.peerId;
+            const fromId = normalized.fromId;
+
+            // Кэшируем информацию об авторе сообщения, если доступна
+            try {
+                const sender = await event.getSender?.();
+                if (sender) {
+                    entityCache.set(sender.id, sender);
+                    normalized.senderName = sender.title || [sender.firstName, sender.lastName].filter(Boolean).join(" ") || normalized.senderName;
+                }
+            } catch {
+                // Игнорируем
+            }
+
+            bus.emit("new_message", {
+                peerId,
+                fromId,
+                message: normalized,
+                rawEvent: event,
+            });
+        } catch (err) {
+            bus.emit("error", err);
+        }
+    }, new NewMessage({}));
+
+    // 2. Изменённые сообщения
+    on(async (event) => {
+        try {
+            const msg = event.message;
+            if (!msg) return;
+            const normalized = normalizeMessage(msg);
+            bus.emit("edited_message", {
+                peerId: normalized.peerId,
+                message: normalized,
+                rawEvent: event,
+            });
+        } catch (err) {
+            bus.emit("error", err);
+        }
+    }, new EditedMessage({}));
+
+    // 3. Удалённые сообщения
+    on(async (event) => {
+        try {
+            bus.emit("deleted_messages", {
+                peerId: toMarkedId(event.chatId),
+                deletedIds: event.deletedIds || [],
+                rawEvent: event,
+            });
+        } catch (err) {
+            bus.emit("error", err);
+        }
+    }, new DeletedMessage({}));
+
+    // 4. Статус набора текста («печатает...») и другие апдейты
+    on(async (update) => {
+        try {
+            const className = update?.className;
+            if (!className) return;
+
+            if (className === "UpdateUserTyping" || className === "UpdateChatUserTyping" || className === "UpdateChannelUserTyping") {
+                const userId = idToString(update.userId || update.fromId?.userId);
+                // channelId/chatId приходят немаркированными — приводим к формату dialog.id
+                const chatId = updateChatId(update) || userId;
+                const action = update.action?.className || "SendMessageTypingAction";
+
+                bus.emit("typing", {
+                    chatId,
+                    userId,
+                    action,
+                });
+            } else if (className === "UpdateReadHistoryInbox" || className === "UpdateReadChannelInbox") {
+                bus.emit("read_inbox", {
+                    peerId: updateChatId(update),
+                    maxId: update.maxId,
+                    stillUnreadCount: update.stillUnreadCount || 0,
+                });
+            } else if (className === "UpdateReadHistoryOutbox" || className === "UpdateReadChannelOutbox") {
+                bus.emit("read_outbox", {
+                    peerId: updateChatId(update),
+                    maxId: update.maxId,
+                });
+            }
+        } catch (err) {
+            // Игнорируем ошибки парсинга сырых апдейтов
+        }
+    }, new Raw({}));
+
+    /** Останавливает все обработчики */
+    bus.stop = () => {
+        for (const handler of handlers) {
+            try {
+                client.removeEventHandler(handler);
+            } catch {
+                // Игнорируем
+            }
+        }
+        bus.removeAllListeners();
+    };
+
+    return bus;
+}