@emaxe/tuigram 1.3.0 → 1.5.0

package/src/ui/components/modals/videoPlayerModal.js

@@ -0,0 +1,274 @@
+import blessed from "neo-blessed";
+import { fg } from "../../theme.js";
+import { config } from "../../../config.js";
+import { findFfmpegPath, findFfplayPath, spawnVideoPlayer, spawnAudioPlayer } from "../../../utils/video.js";
+import { formatDuration } from "../../../utils/time.js";
+
+/**
+ * Создаёт полноэкранное модальное окно воспроизведения видео в терминале.
+ *
+ * Декодирует видеопоток через ffmpeg и выводит кадры в Unicode Half-Block псевдографике,
+ * синхронизируя аудиодорожку через системный аудиоплеер (afplay / ffplay).
+ *
+ * @param {blessed.Widgets.Screen} screen
+ * @param {object} theme
+ * @param {object} callbacks
+ * @param {(msg: object, onProgress?: (p: number) => void) => Promise<string>} [callbacks.onLoadVideoFile]
+ * @param {(msg: object, size: { maxWidth: number, maxHeight: number }) => string} [callbacks.onRenderPlaceholder]
+ * @returns {{ modal: object, play: (msg: object) => void, hide: () => void, isVisible: () => boolean }}
+ */
+export function createVideoPlayerModal(screen, theme, { onLoadVideoFile, onRenderPlaceholder } = {}) {
+    const modal = blessed.box({
+        parent: screen,
+        top: 0,
+        left: 0,
+        width: "100%",
+        height: "100%",
+        hidden: true,
+        mouse: true,
+        style: {
+            bg: theme.bg,
+            fg: theme.fg,
+        },
+    });
+
+    const canvas = blessed.box({
+        parent: modal,
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 1,
+        tags: true,
+        align: "center",
+        valign: "middle",
+        style: {
+            bg: theme.bg,
+            fg: theme.fg,
+        },
+    });
+
+    const footer = blessed.box({
+        parent: modal,
+        bottom: 0,
+        left: 0,
+        right: 0,
+        height: 1,
+        tags: true,
+        style: {
+            bg: theme.status.bg,
+            fg: theme.status.fg,
+        },
+    });
+
+    let currentMsg = null;
+    let currentVideoPath = null;
+    let videoProcess = null;
+    let audioProcess = null;
+    let isPaused = false;
+    let statusText = "";
+    let previousFocus = null;
+    let token = 0;
+    let frameCount = 0;
+
+    /** Размер холста видео в ячейках/пикселях. */
+    function viewportDimensions() {
+        const screenW = screen.width || 80;
+        const screenH = screen.height || 24;
+        const width = Math.max(10, Math.min(screenW - 2, 80));
+        // Высота в пикселях: 2 пикселя на 1 терминальную строку
+        let height = Math.max(8, Math.min((screenH - 2) * 2, 60));
+        if (height % 2 !== 0) height -= 1;
+        return { width, height };
+    }
+
+    function renderFooter() {
+        const id = currentMsg ? `#${currentMsg.id}` : "";
+        const status = statusText ? `${fg(theme.warning, statusText)} ${fg(theme.dim, "│")} ` : "";
+        const pauseTag = isPaused ? `${fg(theme.danger, "[ПАУЗА]")} ${fg(theme.dim, "│")} ` : "";
+        const fpsTag = videoProcess ? `${fg(theme.dim, `FPS: ${config.videoFps}`)} ${fg(theme.dim, "│")} ` : "";
+
+        footer.setContent(
+            ` ${fg(theme.accent, id)} ${fg(theme.dim, "│")} ${pauseTag}${status}${fpsTag}${fg(theme.muted, "[Space] Пауза · [r] С начала · [Esc/q] Закрыть")}`
+        );
+    }
+
+    function stopProcesses() {
+        if (videoProcess) {
+            videoProcess.kill();
+            videoProcess = null;
+        }
+        if (audioProcess) {
+            audioProcess.kill();
+            audioProcess = null;
+        }
+        isPaused = false;
+    }
+
+    function hide() {
+        token++;
+        stopProcesses();
+        modal.hide();
+        currentMsg = null;
+        currentVideoPath = null;
+        statusText = "";
+        frameCount = 0;
+        canvas.setContent("");
+        if (previousFocus) {
+            previousFocus.focus();
+            previousFocus = null;
+        }
+        screen.render();
+    }
+
+    function togglePause() {
+        if (!videoProcess) return;
+        if (isPaused) {
+            videoProcess.resume();
+            audioProcess?.resume();
+            isPaused = false;
+        } else {
+            videoProcess.pause();
+            audioProcess?.pause();
+            isPaused = true;
+        }
+        renderFooter();
+        screen.render();
+    }
+
+    function startPlayback(filePath, myToken) {
+        if (myToken !== token) return;
+        stopProcesses();
+
+        const ffmpegPath = findFfmpegPath();
+        if (!ffmpegPath) {
+            statusText = "ffmpeg не найден. Запустите: tuigram install-video";
+            renderFooter();
+            screen.render();
+            return;
+        }
+
+        const { width, height } = viewportDimensions();
+        statusText = "";
+        frameCount = 0;
+        renderFooter();
+
+        // Запуск аудиодорожки
+        if (config.videoAudio) {
+            const ffplayPath = findFfplayPath();
+            audioProcess = spawnAudioPlayer(filePath, { ffplayPath });
+        }
+
+        // Запуск декодирования видео
+        videoProcess = spawnVideoPlayer(ffmpegPath, filePath, {
+            width,
+            height,
+            fps: config.videoFps,
+            onFrame: (frameText) => {
+                if (myToken !== token) return;
+                frameCount++;
+                canvas.setContent(frameText);
+                renderFooter();
+                screen.render();
+            },
+            onEnd: () => {
+                if (myToken !== token) return;
+                statusText = "Воспроизведение завершено";
+                if (audioProcess) {
+                    audioProcess.kill();
+                    audioProcess = null;
+                }
+                renderFooter();
+                screen.render();
+            },
+            onError: (err) => {
+                if (myToken !== token) return;
+                statusText = `Ошибка декодирования: ${err.message}`;
+                if (audioProcess) {
+                    audioProcess.kill();
+                    audioProcess = null;
+                }
+                renderFooter();
+                screen.render();
+            },
+        });
+    }
+
+    /**
+     * Открывает полноэкранный плеер для воспроизведения видеосообщения.
+     * @param {object} msg нормализованное сообщение
+     */
+    async function play(msg) {
+        if (!msg) return;
+
+        const myToken = ++token;
+        stopProcesses();
+
+        currentMsg = msg;
+        currentVideoPath = null;
+        previousFocus = screen.focused;
+        isPaused = false;
+
+        // Показываем статичную миниатюру на время подготовки
+        const { width, height } = viewportDimensions();
+        const placeholder = onRenderPlaceholder?.(msg, { maxWidth: width, maxHeight: Math.floor(height / 2) }) || "";
+        canvas.setContent(placeholder);
+
+        modal.show();
+        modal.setFront();
+        modal.focus();
+
+        if (!config.enableVideo) {
+            statusText = "Проигрывание видео выключено. Включите ENABLE_VIDEO=true в .env";
+            renderFooter();
+            screen.render();
+            return;
+        }
+
+        const ffmpegPath = findFfmpegPath();
+        if (!ffmpegPath) {
+            statusText = "ffmpeg не найден. Запустите: tuigram install-video";
+            renderFooter();
+            screen.render();
+            return;
+        }
+
+        statusText = "Загрузка видеофайла...";
+        renderFooter();
+        screen.render();
+
+        try {
+            const filePath = await onLoadVideoFile?.(msg, (p) => {
+                if (myToken !== token) return;
+                const percent = Math.round((p || 0) * 100);
+                statusText = `Загрузка: ${percent}%...`;
+                renderFooter();
+                screen.render();
+            });
+
+            if (myToken !== token || !filePath) return;
+            currentVideoPath = filePath;
+            startPlayback(filePath, myToken);
+        } catch (err) {
+            if (myToken !== token) return;
+            statusText = `Ошибка загрузки: ${err.message}`;
+            renderFooter();
+            screen.render();
+        }
+    }
+
+    modal.key(["space"], togglePause);
+    modal.key(["r", "R"], () => {
+        if (currentVideoPath) {
+            startPlayback(currentVideoPath, token);
+        }
+    });
+    modal.key(["escape", "q"], hide);
+    modal.on("click", togglePause);
+
+    return {
+        modal,
+        play,
+        hide,
+        isVisible: () => modal.visible,
+    };
+}

package/src/ui/components/statusBar.js

@@ -1,7 +1,7 @@
 import blessed from "neo-blessed";
 import { fg } from "../theme.js";
 
-import { getStatusBarActionAt } from "../../utils/mouse.js";
+import { getStatusBarActionAt, isRightClick } from "../../utils/mouse.js";
 
 /**
  * Создаёт нижнюю строку состояния (Status Bar) с подсказками и временными тостами.
@@ -43,6 +43,7 @@ export function createStatusBar(screen, theme, {
     });
 
     statusBar.on("click", (data) => {
+        if (isRightClick(data)) return;
         const relX = data.x - (statusBar.aleft || 0);
         const action = getStatusBarActionAt(relX, statusBar.width || 120);
         switch (action) {

package/src/ui/modalMouse.js

@@ -0,0 +1,43 @@
+/**
+ * Общее мышиное поведение модальных окон.
+ */
+
+import { isInsideBox } from "../utils/mouse.js";
+
+/**
+ * Подключает закрытие модального окна по клику мимо него.
+ *
+ * neo-blessed рассылает клик сначала элементу под курсором, а сразу за ним, в том же
+ * такте, — экрану (см. Screen.prototype._listenMouse). Поэтому клик, которым окно
+ * открыли (кнопка строки состояния, шапка, сообщение в ленте), доходил бы до этого
+ * обработчика и закрывал только что открытое окно. Возвращаемая функция «взводит»
+ * закрытие лишь на следующем такте — её вызывает show() окна.
+ *
+ * @param {import("neo-blessed").Widgets.Screen} screen
+ * @param {import("neo-blessed").Widgets.BoxElement} modal
+ * @param {() => void} hide
+ * @returns {() => void} arm — взводит закрытие по внешнему клику
+ */
+export function bindOutsideClickClose(screen, modal, hide) {
+    let armed = false;
+
+    screen.on("click", (data) => {
+        if (!armed || !modal.visible) return;
+        const inside = isInsideBox(data.x, data.y, {
+            left: modal.aleft,
+            top: modal.atop,
+            width: modal.width,
+            height: modal.height,
+        });
+        if (!inside) {
+            hide();
+        }
+    });
+
+    return () => {
+        armed = false;
+        setImmediate(() => {
+            armed = true;
+        });
+    };
+}

package/src/ui/screen.js

@@ -1,5 +1,113 @@
 import blessed from "neo-blessed";
 
+// Патч neo-blessed: предотвращаем дублирование обработчиков keypress и циклы фокуса.
+// В neo-blessed при повторном focus() на уже сфокусированном элементе происходил blur+focus,
+// а readInput() создавал висячие обработчики keypress в nextTick, из-за чего вводимые символы
+// дублировались (например, "ттуутт??").
+if (!blessed.__tuigramPatched) {
+    blessed.__tuigramPatched = true;
+
+    const origElementFocus = blessed.element.prototype.focus;
+    blessed.element.prototype.focus = function() {
+        if (this.screen?.focused === this) return this;
+        return origElementFocus.call(this);
+    };
+
+    const origScreenFocusPush = blessed.screen.prototype.focusPush;
+    blessed.screen.prototype.focusPush = function(el) {
+        if (!el) return;
+        const old = this.history[this.history.length - 1];
+        if (old === el) return;
+        return origScreenFocusPush.call(this, el);
+    };
+
+    blessed.textarea.prototype.readInput = function(callback) {
+        const self = this;
+        const focused = this.screen.focused === this;
+
+        if (this._reading) return;
+        this._reading = true;
+
+        this._callback = callback;
+
+        if (!focused) {
+            this.screen.saveFocus();
+            this.focus();
+        }
+
+        this.screen.grabKeys = true;
+        this._updateCursor();
+        this.screen.program.showCursor();
+
+        if (this.__listener) {
+            this.removeListener("keypress", this.__listener);
+            delete this.__listener;
+        }
+        if (this.__done) {
+            this.removeListener("blur", this.__done);
+            delete this.__done;
+        }
+
+        this._done = function fn(err, value) {
+            if (!self._reading) return;
+
+            if (fn.done) return;
+            fn.done = true;
+
+            self._reading = false;
+
+            delete self._callback;
+            delete self._done;
+
+            if (self.__listener) {
+                self.removeListener("keypress", self.__listener);
+                delete self.__listener;
+            }
+            if (self.__done) {
+                self.removeListener("blur", self.__done);
+                delete self.__done;
+            }
+
+            self.screen.program.hideCursor();
+            self.screen.grabKeys = false;
+
+            if (!focused) {
+                self.screen.restoreFocus();
+            }
+
+            if (self.options.inputOnFocus) {
+                self.screen.rewindFocus();
+            }
+
+            if (err === "stop") return;
+
+            if (err) {
+                self.emit("error", err);
+            } else if (value != null) {
+                self.emit("submit", value);
+            } else {
+                self.emit("cancel", value);
+            }
+            self.emit("action", value);
+
+            if (!callback) return;
+            return err ? callback(err) : callback(null, value);
+        };
+
+        setImmediate(() => {
+            if (!self._reading) return;
+            if (self.__listener) {
+                self.removeListener("keypress", self.__listener);
+            }
+            self.__listener = self._listener.bind(self);
+            self.on("keypress", self.__listener);
+        });
+
+        this.__done = this._done.bind(this, null, null);
+        this.on("blur", this.__done);
+    };
+}
+
 /**
  * Глобальные сочетания, которые должны работать даже когда поле ввода или строка
  * поиска перехватили клавиатуру (blessed выставляет screen.grabKeys = true и
@@ -15,10 +123,58 @@ export const GLOBAL_KEYS = [
     "C-r",
     "C-e",
     "C-p",
+    // C-a — меню действий над выделенным сообщением, f12 — тумблер захвата мыши
+    "C-a",
+    "f12",
     // escape — чтобы можно было прервать отправку файла из любого места
     "escape",
 ];
 
+/**
+ * Включение мыши: 1000 — кнопки, 1002 — клики/перетаскивание/колесо,
+ * 1006 — SGR-кодирование координат, 1015 — urxvt как запасной вариант.
+ * Режимы 1003 (все движения) и 1005 (UTF-8) явно гасим: они ломают разбор в blessed.
+ */
+const ENABLE_MOUSE_SEQ = "\x1b[?1003l\x1b[?1005l\x1b[?1000h\x1b[?1002h\x1b[?1006h\x1b[?1015h";
+const DISABLE_MOUSE_SEQ = "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1005l\x1b[?1006l\x1b[?1015l";
+
+/**
+ * Пишет escape-последовательность напрямую в терминал.
+ * @param {import("neo-blessed").Widgets.Screen} screen
+ * @param {string} seq
+ */
+function writeSeq(screen, seq) {
+    try {
+        if (screen.program?.output && typeof screen.program.output.write === "function") {
+            screen.program.output.write(seq);
+        }
+    } catch {
+        // Игнорируем в headless/тестах
+    }
+}
+
+/**
+ * Включает или выключает захват мыши терминалом приложения.
+ * Пока захват включён, терминал не отдаёт пользователю выделение текста мышью,
+ * поэтому нужен способ временно его отпустить (F12).
+ * @param {import("neo-blessed").Widgets.Screen} screen
+ * @param {boolean} enabled
+ */
+export function setMouseCapture(screen, enabled) {
+    screen.mouseCaptured = enabled;
+    if (enabled) {
+        writeSeq(screen, ENABLE_MOUSE_SEQ);
+        screen.program.enableMouse();
+    } else {
+        try {
+            screen.program.disableMouse();
+        } catch {
+            // Игнорируем в headless/тестах
+        }
+        writeSeq(screen, DISABLE_MOUSE_SEQ);
+    }
+}
+
 /**
  * Создаёт и настраивает главный экран терминального интерфейса.
  * @param {object} [options]
@@ -63,25 +219,20 @@ export function createScreen({ theme, onExit } = {}) {
         utfMouse: false,
     }, true);
 
-    const enableMouseSeq = "\x1b[?1003l\x1b[?1005l\x1b[?1000h\x1b[?1002h\x1b[?1006h\x1b[?1015h";
-    const disableMouseSeq = "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1005l\x1b[?1006l\x1b[?1015l";
+    screen.mouseCaptured = true;
+    writeSeq(screen, ENABLE_MOUSE_SEQ);
+    screen.enableMouse();
 
-    function sendEnableMouse() {
-        try {
-            if (screen.program && screen.program.output && typeof screen.program.output.write === "function") {
-                screen.program.output.write(enableMouseSeq);
-            }
-        } catch {
-            // Игнорируем в headless/тестах
-        }
+    // Режимы мыши переотправляются после каждой перерисовки и при ресайзе.
+    // Это выглядит избыточным, но без этого часть терминалов перестаёт слать
+    // события мыши приложению: попытка убрать переотправку ломала клики целиком.
+    // Не удалять без проверки в живом терминале — headless-тесты этого не ловят.
+    function restoreMouse() {
+        if (screen.mouseCaptured) writeSeq(screen, ENABLE_MOUSE_SEQ);
     }
 
-    sendEnableMouse();
-    screen.enableMouse();
-
-    // Отправляем escape-последовательности повторно при перерендере/ресайзе экрана
-    screen.on("render", sendEnableMouse);
-    screen.on("resize", sendEnableMouse);
+    screen.on("render", restoreMouse);
+    screen.on("resize", restoreMouse);
 
     // Пробрасываем событие click на уровне экрана при mouseup
     screen.on("mouseup", (data) => {
@@ -91,10 +242,7 @@ export function createScreen({ theme, onExit } = {}) {
     // Обработка закрытия терминала или аварийного прерывания
     function cleanExit() {
         try {
-            if (screen.program && screen.program.output && typeof screen.program.output.write === "function") {
-                screen.program.output.write(disableMouseSeq);
-            }
-            screen.program.disableMouse();
+            setMouseCapture(screen, false);
             onExit?.();
         } catch {
             // Выходим в любом случае

package/src/ui/theme.js

@@ -68,6 +68,7 @@ function buildTheme(p) {
             outgoingName: p.green,
             time: p.dim,
             dateDivider: p.yellow,
+            unreadDivider: p.accent,
             replyBorder: p.muted,
             systemMsg: p.yellow,
             mediaFg: p.magenta,