@will-17173/telegram-cli 0.1.1 → 0.3.0

package/dist/presenters/ink/listen.js

@@ -7,11 +7,26 @@ import { homedir } from 'node:os';
 import { dirname } from 'node:path';
 import { resolveAttachmentDestination } from '../../services/attachment-download.js';
 import { ListenAlbumAggregator } from '../../services/listen-album-aggregator.js';
+import { AutoDownloadCoordinator } from '../../services/auto-download-coordinator.js';
+import { attachmentDownloadTarget, attachmentFileName, discoverListenAttachments, listenAttachmentKey } from '../../services/listen-attachment.js';
 import { buildListenMessage } from '../listen-message.js';
-import { applyMessageArrival, applyScroll, takeListenViewport } from './listen-scroll.js';
+import { applyMessageArrival, takeListenViewport } from './listen-scroll.js';
 import { decodeImagePreview } from './image-preview.js';
 import { ListenScrollbar, calculateScrollbar, listenContentWidth, useTransientScrollbar } from './listen-scrollbar.js';
-import { isMouseInput, useMouseScroll, withMouseReporting } from './mouse-scroll.js';
+import { DISABLE_MOUSE_REPORTING, isMouseInput } from './mouse-scroll.js';
+import { createListenReplyResolver } from '../../services/listen-reply-resolver.js';
+import { formatReplyContext } from '../../services/reply-context.js';
+import { executeListenReply, parseListenComposerInput } from '../../services/listen-composer-command.js';
+import { ListenCommandMenu, listenCommandMenuAvailability, moveListenCommandSelectionEnabled } from './listen-command-menu.js';
+import { completeListenCommand, visibleListenCommandMatches } from '../../listen-commands/match.js';
+import { parseSelectedListenCommand } from '../../listen-commands/dispatch.js';
+import { GroupCommandResult } from './group-command-result.js';
+import { useGroupCommand } from './use-group-command.js';
+import { executeGroupCommand } from '../../group-commands/executor.js';
+import { GroupWriteService } from '../../services/group-write-service.js';
+import { ADMIN_RIGHT_KEYS } from '../../services/group-write-service.js';
+import { GroupCommandConfirm } from './group-command-confirm.js';
+import { truncateCell } from './display-width.js';
 const MESSAGE_SEPARATOR = '────────────────────────────────────────────';
 /** Maximum number of grouped messages retained by a long-running interactive listener. */
 export const LISTEN_HISTORY_LIMIT = 500;
@@ -54,24 +69,315 @@ export function ListenComposer({ input, sendTargetLabel, terminalWidth, sending
 export function ListenAttachmentLine({ label, selected, state }) {
     const action = state.status === 'idle'
         ? '󰇚 Download'
-        : state.status === 'downloading'
-            ? `Downloading${state.progress == null ? '...' : ` ${state.progress}%`}`
-            : state.status === 'completed'
-                ? state.path
-                : `Failed: ${state.error}`;
+        : state.status === 'queued'
+            ? 'Queued'
+            : state.status === 'downloading'
+                ? `Downloading${state.progress == null ? '...' : ` ${state.progress}%`}`
+                : state.status === 'completed'
+                    ? state.path
+                    : `Failed: ${state.error}`;
     return (_jsxs(Text, { wrap: "truncate-end", backgroundColor: selected ? '#3b5368' : undefined, color: selected ? 'white' : undefined, children: [selected ? '› ' : '  ', label, "  [", action, "]"] }));
 }
+export function applyAutoDownloadEvent(current, event, showMedia = true) {
+    if (!showMedia)
+        return Object.keys(current).length === 0 ? current : {};
+    if (event.status === 'cancelled') {
+        if (!(event.key in current))
+            return current;
+        const next = { ...current };
+        delete next[event.key];
+        return next;
+    }
+    const state = event.status === 'queued'
+        ? { status: 'queued' }
+        : event.status === 'downloading'
+            ? { status: 'downloading', progress: event.progress }
+            : event.status === 'completed'
+                ? { status: 'completed', path: event.path }
+                : { status: 'failed', error: event.error };
+    return { ...current, [event.key]: state };
+}
+export function canManuallyDownload(state) {
+    return state.status === 'idle' || state.status === 'failed';
+}
+export function createInteractiveOperationController() {
+    let generation = 0;
+    let sequence = 0;
+    let sendOperation = 0;
+    const downloadOperations = new Map();
+    return {
+        beginGeneration() {
+            const ownedGeneration = ++generation;
+            let active = true;
+            return {
+                isActive: () => active && generation === ownedGeneration,
+                dispose: () => {
+                    active = false;
+                    if (generation === ownedGeneration) {
+                        generation += 1;
+                        downloadOperations.clear();
+                    }
+                },
+            };
+        },
+        beginSend() {
+            const ownedGeneration = generation;
+            const operation = ++sendOperation;
+            return () => generation === ownedGeneration && sendOperation === operation;
+        },
+        beginDownload(key) {
+            const ownedGeneration = generation;
+            const operation = ++sequence;
+            downloadOperations.set(key, operation);
+            return {
+                isCurrent: () => generation === ownedGeneration && downloadOperations.get(key) === operation,
+                release: () => {
+                    if (downloadOperations.get(key) === operation)
+                        downloadOperations.delete(key);
+                },
+            };
+        },
+        claimDownload(key) {
+            const operation = ++sequence;
+            downloadOperations.set(key, operation);
+            return {
+                release: () => {
+                    if (downloadOperations.get(key) === operation)
+                        downloadOperations.delete(key);
+                },
+            };
+        },
+        downloadOwnershipSize: () => downloadOperations.size,
+    };
+}
+export async function runOwnedAttachmentOperation(ownership, operation, onError) {
+    try {
+        await operation();
+    }
+    catch (error) {
+        if (ownership.isCurrent())
+            onError(error);
+    }
+    finally {
+        ownership.release();
+    }
+}
+export function pruneAttachmentDownloadStates(current, validKeys, pendingKeys = new Set()) {
+    const retained = Object.fromEntries(Object.entries(current).filter(([key, state]) => (validKeys.has(key) || pendingKeys.has(key) || state.status === 'queued' || state.status === 'downloading')));
+    return Object.keys(retained).length === Object.keys(current).length ? current : retained;
+}
+export function registerPendingAttachmentKeys(pendingKeys, message, showMedia) {
+    if (!showMedia) {
+        pendingKeys.clear();
+        return;
+    }
+    discoverListenAttachments(message).forEach((attachment, index) => {
+        if (attachment.downloadable)
+            pendingKeys.add(listenAttachmentKey(attachment, index));
+    });
+}
+export function acceptListenMessage(message, seen, seenOrder, emit) {
+    const key = `${message.chat_id}:${message.msg_id}`;
+    if (seen.has(key))
+        return false;
+    seen.add(key);
+    seenOrder.push(key);
+    if (seen.size > 5000) {
+        const oldest = seenOrder.shift();
+        if (oldest != null)
+            seen.delete(oldest);
+    }
+    emit(message);
+    return true;
+}
+export async function runInteractiveAutoDownloadLifecycle(options) {
+    const coordinator = options.autoDownload
+        ? (options.createCoordinator ?? (() => new AutoDownloadCoordinator()))()
+        : null;
+    options.onCoordinator?.(coordinator);
+    let currentClient = null;
+    const abort = () => {
+        coordinator?.stop();
+        void currentClient?.close().catch(() => undefined);
+    };
+    options.signal.addEventListener('abort', abort);
+    try {
+        while (!options.signal.aborted) {
+            options.onStatus?.('connecting');
+            const client = options.createClient();
+            currentClient = client;
+            options.onClient?.(client);
+            coordinator?.setClient(client);
+            let retry = false;
+            try {
+                const result = await client.listen({
+                    chats: options.chats,
+                    signal: options.signal,
+                    onConnected: () => options.onStatus?.('connected'),
+                    onMessage: (message) => {
+                        if (options.signal.aborted)
+                            return;
+                        if (options.acceptMessage?.(message) === false)
+                            return;
+                        options.onBeforeEnqueue?.(message);
+                        coordinator?.enqueue(message);
+                        options.onMessage(message);
+                    },
+                });
+                if (options.persist && result === 'disconnected') {
+                    retry = true;
+                    options.onStatus?.('disconnected');
+                }
+                else {
+                    options.onStatus?.('stopped');
+                }
+            }
+            catch (error) {
+                if (options.persist && !options.signal.aborted)
+                    retry = true;
+                options.onError?.(error);
+            }
+            finally {
+                options.flush?.();
+                if (retry) {
+                    coordinator?.setClient(null);
+                    await coordinator?.waitForActive();
+                }
+                else if (!options.signal.aborted) {
+                    await coordinator?.waitForIdle();
+                }
+                else {
+                    coordinator?.stop();
+                }
+                await client.close().catch(() => undefined);
+                if (options.signal.aborted)
+                    await coordinator?.waitForActive();
+                if (currentClient === client)
+                    currentClient = null;
+                options.onClient?.(null);
+            }
+            if (!retry)
+                break;
+            await (options.sleep ?? sleep)(options.retrySeconds);
+        }
+    }
+    finally {
+        options.signal.removeEventListener('abort', abort);
+        options.onCoordinator?.(null);
+    }
+}
+export function attachmentDownloadKeyAt(attachments, index) {
+    const attachment = attachments[index];
+    if (attachment == null)
+        throw new Error(`Missing attachment at index ${index}`);
+    const sourceIndex = attachments.slice(0, index).filter((candidate) => (candidate.chatId === attachment.chatId && candidate.messageId === attachment.messageId)).length;
+    return listenAttachmentKey(attachment, sourceIndex);
+}
 export function ListenImagePreview({ rows }) {
     return (_jsx(Box, { flexDirection: "column", children: rows.map((row, rowIndex) => (_jsxs(Text, { children: ["  ", row.map((cell, cellIndex) => (_jsx(Text, { color: cell.foreground, backgroundColor: cell.background, children: cell.glyph }, cellIndex)))] }, rowIndex))) }));
 }
-export function ListenAttachmentWithPreview({ label, selected, state, previewCells, }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ListenAttachmentLine, { label: label, selected: selected, state: state }), previewCells == null ? null : _jsx(ListenImagePreview, { rows: previewCells })] }));
+export function ListenAttachmentWithPreview({ label, downloadable = true, selected, state, previewCells, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [downloadable
+                ? _jsx(ListenAttachmentLine, { label: label, selected: selected, state: state })
+                : _jsxs(Text, { wrap: "truncate-end", children: ["  ", label] }), previewCells == null ? null : _jsx(ListenImagePreview, { rows: previewCells })] }));
+}
+export function ListenMessageBody({ message }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [message.replyContext == null ? null : _jsx(Text, { wrap: "truncate-end", children: formatReplyContext(message.replyContext) }), message.content == null ? null : _jsx(Text, { wrap: "truncate-end", children: message.content }), message.mediaSummary == null ? null : _jsx(Text, { wrap: "truncate-end", children: message.mediaSummary }), message.media.map((item, mediaIndex) => (_jsx(ListenAttachmentWithPreview, { label: item.label, downloadable: item.downloadable, selected: false, state: { status: 'idle' }, previewCells: item.previewCells }, attachmentDownloadKeyAt(message.media, mediaIndex))))] }));
+}
+export function createInteractiveListenGroupQueue(options) {
+    const pending = [];
+    const schedule = options.schedule ?? ((run) => setImmediate(run));
+    let scheduled = null;
+    let resolveScheduled = null;
+    let closing = false;
+    let closed = false;
+    let closePromise = null;
+    const closeResolver = async () => {
+        if (closed)
+            return;
+        closed = true;
+        if (options.resolver.closeAsync != null)
+            await options.resolver.closeAsync();
+        else
+            options.resolver.close();
+    };
+    const drain = async () => {
+        try {
+            while (pending.length > 0) {
+                const messages = pending.shift();
+                try {
+                    const replyContext = options.resolver.resolveAsync == null
+                        ? options.resolver.resolve(messages)
+                        : await options.resolver.resolveAsync(messages);
+                    options.resolver.remember(messages);
+                    const first = messages[0];
+                    if (first != null && options.isActive()) {
+                        options.onGroup({ key: `${first.chat_id}:${first.msg_id}`, messages, replyContext });
+                    }
+                }
+                catch (error) {
+                    options.onError(error);
+                    pending.length = 0;
+                    break;
+                }
+            }
+        }
+        finally {
+            resolveScheduled?.();
+            resolveScheduled = null;
+            scheduled = null;
+        }
+    };
+    return {
+        enqueue(messages) {
+            if (closing)
+                return;
+            pending.push(messages);
+            if (scheduled != null)
+                return;
+            scheduled = new Promise((resolve) => { resolveScheduled = resolve; });
+            schedule(() => { void drain(); });
+        },
+        close() {
+            closePromise ??= (async () => {
+                closing = true;
+                const drainCompletion = scheduled;
+                if (drainCompletion != null)
+                    await drainCompletion;
+                await closeResolver();
+            })();
+            return closePromise;
+        },
+    };
+}
+export function createInteractiveListenRuntime(dbPath, factory, options) {
+    return createInteractiveListenGroupQueue({
+        ...options,
+        resolver: factory(dbPath, LISTEN_HISTORY_LIMIT),
+    });
 }
 export function ListenStatus({ status, unseenCount }) {
     return _jsxs(Text, { dimColor: true, children: [status, unseenCount > 0 ? ` · ↓ ${unseenCount} new messages` : ''] });
 }
+export function formatInteractiveListenSender(message) {
+    const sender = message.senderId == null || message.sender === String(message.senderId)
+        ? message.sender
+        : `${message.sender} (${message.senderId})`;
+    return message.chatName == null ? sender : `${message.chatName} | ${sender}`;
+}
+export function formatInteractiveListenHeader(message) {
+    return `[${message.time}] #${message.msgId} ${formatInteractiveListenSender(message)}`;
+}
+export function ListenStatusArea({ status, unseenCount, autoDownload, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ListenStatus, { status: status, unseenCount: unseenCount }), autoDownload ? _jsx(Text, { dimColor: true, children: "Auto-download enabled" }) : null] }));
+}
+export function calculateListenMessagePaneHeight(terminalHeight, hasNote, autoDownload) {
+    const reservedLines = 7 + (hasNote ? 1 : 0) + (autoDownload ? 1 : 0);
+    return Math.max(2, terminalHeight - reservedLines);
+}
 export async function runInteractiveListen(write, run) {
-    return withMouseReporting({ write, run });
+    write(DISABLE_MOUSE_REPORTING);
+    return run();
 }
 export async function renderInteractiveListen(options) {
     await runInteractiveListen(process.stdout.write.bind(process.stdout), async () => {
@@ -79,7 +385,7 @@ export async function renderInteractiveListen(options) {
         await app.waitUntilExit();
     });
 }
-function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, showChatName, createClient, stopSignal, onRequestStop, }) {
+export function InteractiveListen({ dbPath, chats, persist, retrySeconds, sendTo, showMedia, autoDownload, showChatName, createClient, stopSignal, onRequestStop, createReplyResolver, }) {
     const { exit } = useApp();
     const { stdout } = useStdout();
     const terminalMetrics = useTerminalMetrics(stdout);
@@ -93,42 +399,97 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, sh
     const [downloadStates, setDownloadStates] = useState({});
     const [scrollState, setScrollState] = useState({ offset: 0, unseenCount: 0 });
     const [sendTargetLabel, setSendTargetLabel] = useState(sendTo == null ? '' : buildSendTargetLabel(sendTo));
+    const [knownGroup, setKnownGroup] = useState(undefined);
+    const clientRef = useRef(null);
+    const replyExecutionLockRef = useRef(false);
+    const inputGenerationRef = useRef(0);
+    const commandSelectionRef = useRef(0);
+    const knownGroupRef = useRef(undefined);
+    const groupLookupGenerationRef = useRef(0);
+    useEffect(() => {
+        groupLookupGenerationRef.current++;
+        knownGroupRef.current = undefined;
+        setKnownGroup(undefined);
+    }, [sendTo]);
+    const groupCommand = useGroupCommand(useCallback(async (request, options) => {
+        const client = clientRef.current;
+        if (client == null)
+            return { ok: false, error: { code: 'connection_not_ready', message: 'Telegram connection is not ready.' } };
+        if (sendTo == null)
+            return { ok: false, error: { code: 'ambiguous_chat', message: 'Select exactly one target chat with --send-to.' } };
+        let knownGroup = knownGroupRef.current;
+        if (knownGroup == null) {
+            const lookup = ++groupLookupGenerationRef.current;
+            knownGroup = await client.groups.getGroup(sendTo);
+            if (lookup === groupLookupGenerationRef.current && clientRef.current === client) {
+                knownGroupRef.current = knownGroup;
+                setKnownGroup(knownGroup);
+            }
+        }
+        return executeGroupCommand(request, {
+            chat: sendTo,
+            groups: new GroupWriteService(client.groups),
+            confirmed: options?.confirmed ?? false,
+            confirmationTitle: options?.confirmationTitle,
+            knownGroup,
+            connectionReady: true,
+            targetAvailable: true,
+            targetCount: 1,
+            invalidateGroup: async () => {
+                knownGroupRef.current = undefined;
+                setKnownGroup(undefined);
+                if (request.key === 'chat delete' || request.key === 'chat leave')
+                    return;
+                const lookup = ++groupLookupGenerationRef.current;
+                try {
+                    const refreshed = await client.groups.getGroup(sendTo);
+                    if (lookup === groupLookupGenerationRef.current && clientRef.current === client) {
+                        knownGroupRef.current = refreshed;
+                        setKnownGroup(refreshed);
+                    }
+                }
+                catch (error) {
+                    if (lookup === groupLookupGenerationRef.current && clientRef.current === client)
+                        setNote(`Group updated; refresh failed: ${messageFromError(error)}`);
+                }
+            },
+        });
+    }, [sendTo]));
     const terminalWidth = terminalMetrics.columns;
     const terminalHeight = terminalMetrics.rows;
     const previewColorDepth = interactiveListenPreviewColorDepth(terminalMetrics.colorDepth);
     const contentWidth = listenContentWidth(terminalWidth);
     const previewWidth = Math.max(1, Math.min(24, contentWidth - 2));
+    const renderContextRef = useRef({ showMedia, previewWidth, colorDepth: previewColorDepth, showChatName });
+    renderContextRef.current = { showMedia, previewWidth, colorDepth: previewColorDepth, showChatName };
     const messageViewCacheRef = useRef(null);
     if (messageViewCacheRef.current == null)
         messageViewCacheRef.current = new ListenMessageViewCache();
-    const messages = useMemo(() => messageViewCacheRef.current.build(messageGroups, {
-        showMedia,
-        previewWidth,
-        colorDepth: previewColorDepth,
-        showChatName,
-    }), [messageGroups, showMedia, previewWidth, previewColorDepth, showChatName]);
-    const reservedLines = 7 + (note ? 1 : 0);
-    const messagePaneHeight = Math.max(2, terminalHeight - reservedLines);
+    const messages = useMemo(() => messageViewCacheRef.current.build(messageGroups, renderContextRef.current), [messageGroups, showMedia, previewWidth, previewColorDepth, showChatName]);
+    const messagePaneHeight = calculateListenMessagePaneHeight(terminalHeight, note.length > 0, autoDownload);
     const visibleMessages = takeListenViewport(messages, messagePaneHeight, scrollState.offset);
-    const clientRef = useRef(null);
+    const closeGroupCommand = () => {
+        commandSelectionRef.current = 0;
+        groupCommand.close();
+    };
     const albumAggregatorRef = useRef(null);
+    const autoDownloaderRef = useRef(null);
+    const pendingAttachmentKeysRef = useRef(new Set());
+    const operationControllerRef = useRef(null);
+    if (operationControllerRef.current == null)
+        operationControllerRef.current = createInteractiveOperationController();
     const stoppingRef = useRef(false);
     const seenRef = useRef(new Set());
     const seenOrderRef = useRef([]);
-    const downloadableAttachments = collectAttachments(visibleMessages);
+    const downloadableAttachments = collectDownloadableAttachments(visibleMessages);
     const selectedAttachment = downloadableAttachments[selectedAttachmentIndex] ?? downloadableAttachments[0];
-    const { visible: scrollbarVisible, show: showScrollbar } = useTransientScrollbar();
+    const { visible: scrollbarVisible } = useTransientScrollbar();
     const scrollbarGeometry = calculateScrollbar({
         height: terminalHeight,
         total: messages.length,
         visible: visibleMessages.length,
         offset: scrollState.offset,
     });
-    const handleMouseScroll = useCallback((direction) => {
-        showScrollbar();
-        setScrollState((current) => applyScroll(current, direction, Math.max(0, messages.length - 1)));
-    }, [messages.length, showScrollbar]);
-    useMouseScroll(handleMouseScroll);
     useEffect(() => {
         const maxOffset = Math.max(0, messages.length - 1);
         setScrollState((current) => {
@@ -138,11 +499,12 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, sh
                 ? current
                 : { offset, unseenCount };
         });
-        const validAttachmentKeys = new Set(collectAttachments(messages).map((item) => item.key));
-        setDownloadStates((current) => {
-            const retained = Object.fromEntries(Object.entries(current).filter(([key]) => validAttachmentKeys.has(key)));
-            return Object.keys(retained).length === Object.keys(current).length ? current : retained;
-        });
+        const validAttachmentKeys = new Set(collectDownloadableAttachments(messages).map((item) => item.key));
+        if (!showMedia)
+            pendingAttachmentKeysRef.current.clear();
+        setDownloadStates((current) => pruneAttachmentDownloadStates(current, validAttachmentKeys, pendingAttachmentKeysRef.current));
+        for (const key of validAttachmentKeys)
+            pendingAttachmentKeysRef.current.delete(key);
         setSelectedAttachmentIndex((current) => Math.min(current, Math.max(0, downloadableAttachments.length - 1)));
         if (downloadableAttachments.length === 0)
             setFocus('input');
@@ -154,6 +516,139 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, sh
             stopListening();
             return;
         }
+        const modal = groupCommand.state;
+        if (modal.kind === 'confirm') {
+            if (key.escape) {
+                closeGroupCommand();
+                return;
+            }
+            if (key.upArrow || key.downArrow) {
+                groupCommand.setState({ ...modal, selectedIndex: modal.selectedIndex === 0 ? 1 : 0 });
+                return;
+            }
+            if (key.return) {
+                if (modal.selectedIndex === 0)
+                    void groupCommand.runConfirmed(modal.request);
+                else
+                    closeGroupCommand();
+            }
+            return;
+        }
+        if (modal.kind === 'confirm-title') {
+            if (key.escape) {
+                if (modal.stage === 'title')
+                    groupCommand.setState({ ...modal, stage: 'confirm', confirmText: '', mismatch: false });
+                else
+                    closeGroupCommand();
+                return;
+            }
+            if (modal.stage === 'confirm') {
+                if (key.upArrow || key.downArrow)
+                    groupCommand.setState({ ...modal, selectedIndex: modal.selectedIndex === 0 ? 1 : 0 });
+                else if (key.return)
+                    modal.selectedIndex === 0 ? groupCommand.setState({ ...modal, stage: 'title' }) : closeGroupCommand();
+                return;
+            }
+            if (key.return) {
+                const client = clientRef.current;
+                if (client == null || sendTo == null) {
+                    groupCommand.setState({ kind: 'error', message: 'Telegram connection is not ready.' });
+                }
+                else {
+                    const submittedTitle = modal.confirmText;
+                    const lookup = ++groupLookupGenerationRef.current;
+                    void client.groups.getGroup(sendTo).then((fresh) => {
+                        if (lookup !== groupLookupGenerationRef.current || clientRef.current !== client)
+                            return;
+                        knownGroupRef.current = fresh;
+                        setKnownGroup(fresh);
+                        if (fresh.title === submittedTitle)
+                            void groupCommand.runConfirmed(modal.request, submittedTitle);
+                        else if ('confirmation' in modal.pending)
+                            groupCommand.setState({
+                                ...modal,
+                                pending: { ...modal.pending, confirmation: { ...modal.pending.confirmation, title: fresh.title, target: fresh.title } },
+                                mismatch: true,
+                            });
+                    }).catch((error) => {
+                        if (lookup === groupLookupGenerationRef.current && clientRef.current === client)
+                            groupCommand.setState({ kind: 'error', message: messageFromError(error) });
+                    });
+                }
+            }
+            else if (key.backspace || key.delete)
+                groupCommand.setState({ ...modal, confirmText: modal.confirmText.slice(0, -1), mismatch: false });
+            else if (!key.ctrl && !key.meta && inputText)
+                groupCommand.setState({ ...modal, confirmText: modal.confirmText + inputText, mismatch: false });
+            return;
+        }
+        if (modal.kind === 'select-permissions') {
+            if (key.escape) {
+                closeGroupCommand();
+                return;
+            }
+            if (key.upArrow || key.downArrow) {
+                const delta = key.upArrow ? -1 : 1;
+                groupCommand.setState({ ...modal, selectedIndex: (modal.selectedIndex + delta + ADMIN_RIGHT_KEYS.length) % ADMIN_RIGHT_KEYS.length });
+            }
+            else if (inputText === ' ') {
+                const right = ADMIN_RIGHT_KEYS[modal.selectedIndex];
+                groupCommand.setState({ ...modal, selected: modal.selected.includes(right) ? modal.selected.filter(item => item !== right) : [...modal.selected, right], warning: undefined });
+            }
+            else if (key.return) {
+                if (modal.selected.length === 0)
+                    groupCommand.setState({ ...modal, warning: 'Select at least one permission.' });
+                else {
+                    const request = Object.freeze({ ...modal.request, values: Object.freeze({ ...modal.request.values, permissions: Object.freeze([...modal.selected]) }) });
+                    void (async () => {
+                        const result = await groupCommand.submit(`${modal.originalInput} ${modal.selected.join(',')}`, 0);
+                        if (result.kind === 'pending' && 'confirmation' in result.pending)
+                            groupCommand.setState({ kind: 'confirm', pending: result.pending, request, originalInput: modal.originalInput, selectedIndex: 1 });
+                    })();
+                }
+            }
+            return;
+        }
+        if (groupCommand.state.kind === 'result') {
+            if (key.escape)
+                closeGroupCommand();
+            return;
+        }
+        if (key.escape && groupCommand.state.kind === 'error') {
+            closeGroupCommand();
+            return;
+        }
+        const slashMode = input.trimStart().startsWith('/');
+        if (slashMode && key.escape) {
+            if (replyExecutionLockRef.current) {
+                inputGenerationRef.current++;
+                setSending(false);
+            }
+            closeGroupCommand();
+            return;
+        }
+        if (slashMode && (key.upArrow || key.downArrow)) {
+            const count = visibleListenCommandMatches(input).length;
+            const disabled = listenCommandMenuAvailability(input, knownGroup).map(Boolean);
+            const selectedIndex = moveListenCommandSelectionEnabled(commandSelectionRef.current, key.upArrow ? -1 : 1, disabled.slice(0, count));
+            commandSelectionRef.current = selectedIndex;
+            groupCommand.setState({ kind: 'menu', selectedIndex });
+            return;
+        }
+        if (slashMode && key.tab) {
+            const selected = commandSelectionRef.current;
+            const failure = listenCommandMenuAvailability(input, knownGroup)[selected];
+            if (failure && 'error' in failure) {
+                setNote(failure.error.message);
+                return;
+            }
+            inputGenerationRef.current++;
+            setInput(completeListenCommand(input, selected));
+            commandSelectionRef.current = 0;
+            groupCommand.setState({ kind: 'menu', selectedIndex: 0 });
+            setFocus('input');
+            return;
+        }
         if (key.tab) {
             if (focus === 'attachments') {
                 setFocus('input');
@@ -181,17 +676,92 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, sh
                 return;
             }
             if (key.return && selectedAttachment != null) {
-                void downloadAttachment(selectedAttachment);
+                const state = downloadStates[selectedAttachment.key] ?? { status: 'idle' };
+                if (canManuallyDownload(state))
+                    void downloadAttachment(selectedAttachment);
             }
             return;
         }
-        if (sending)
+        if (sending || groupCommand.state.kind === 'executing')
             return;
         if (key.return) {
+            if (slashMode) {
+                const selected = commandSelectionRef.current;
+                const failure = listenCommandMenuAvailability(input, knownGroup)[selected];
+                if (failure && 'error' in failure) {
+                    setNote(failure.error.message);
+                    return;
+                }
+                const match = visibleListenCommandMatches(input)[selected];
+                if (!match) {
+                    setNote('No matching command.');
+                    return;
+                }
+                const parsed = parseSelectedListenCommand(input, match);
+                if (parsed.kind === 'complete') {
+                    inputGenerationRef.current++;
+                    setInput(parsed.input);
+                    commandSelectionRef.current = 0;
+                    groupCommand.setState({ kind: 'menu', selectedIndex: 0 });
+                    return;
+                }
+                if (parsed.kind === 'error') {
+                    setNote(parsed.usage == null ? parsed.message : `${parsed.message} · usage: /${parsed.usage}`);
+                    return;
+                }
+                if (parsed.kind === 'reply') {
+                    if (replyExecutionLockRef.current)
+                        return;
+                    if (sendTo == null) {
+                        setNote('set --send-to before replying');
+                        return;
+                    }
+                    const client = clientRef.current;
+                    if (client == null) {
+                        setNote('connection is not ready');
+                        return;
+                    }
+                    replyExecutionLockRef.current = true;
+                    const ownedGeneration = inputGenerationRef.current;
+                    const originalInput = input;
+                    setSending(true);
+                    setNote('sending...');
+                    void executeListenReply(client, sendTo, parsed.command).then((sentMessages) => {
+                        if (ownedGeneration !== inputGenerationRef.current)
+                            return;
+                        for (const sentMessage of sentMessages)
+                            acceptListenMessage(sentMessage, seenRef.current, seenOrderRef.current, (message) => {
+                                registerPendingAttachmentKeys(pendingAttachmentKeysRef.current, message, showMedia);
+                                autoDownloaderRef.current?.enqueue(message);
+                                albumAggregatorRef.current?.add(message);
+                            });
+                        setInput('');
+                        setNote(`replied to #${parsed.command.reply}`);
+                    }).catch((error) => {
+                        if (ownedGeneration === inputGenerationRef.current) {
+                            setInput(originalInput);
+                            setNote(`send failed: ${messageFromError(error)}`);
+                        }
+                    }).finally(() => {
+                        replyExecutionLockRef.current = false;
+                        if (ownedGeneration === inputGenerationRef.current)
+                            setSending(false);
+                    });
+                    return;
+                }
+                void groupCommand.submitParsed(parsed.request, input, selected).then((outcome) => {
+                    if (!outcome.applied)
+                        return;
+                    if (outcome.kind === 'result' && outcome.result.ok)
+                        setInput('');
+                });
+                return;
+            }
             void sendMessage(input);
             return;
         }
         if (key.backspace || key.delete) {
+            inputGenerationRef.current++;
             setInput((current) => current.slice(0, -1));
             return;
         }
@@ -199,10 +769,21 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, sh
             return;
         }
         if (!key.ctrl && !key.meta && inputText.length > 0) {
-            setInput((current) => current + inputText);
+            inputGenerationRef.current++;
+            setInput((current) => {
+                const next = current + inputText;
+                if (next.trimStart().startsWith('/')) {
+                    setFocus('input');
+                    commandSelectionRef.current = 0;
+                    groupCommand.setState({ kind: 'menu', selectedIndex: 0 });
+                }
+                return next;
+            });
         }
     });
     useEffect(() => {
+        const generation = operationControllerRef.current.beginGeneration();
+        const isActive = generation.isActive;
         if (stopSignal.aborted) {
             exit();
             return;
@@ -211,105 +792,149 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, sh
             stopListening();
         };
         stopSignal.addEventListener('abort', stopFromSignal);
+        const groupQueue = createInteractiveListenRuntime(dbPath, createReplyResolver ?? createListenReplyResolver, {
+            isActive,
+            onGroup: (group) => {
+                setScrollState((current) => applyMessageArrival(current));
+                setMessageGroups((current) => [...current, group].slice(-LISTEN_HISTORY_LIMIT));
+            },
+            onError: (error) => {
+                if (!isActive())
+                    return;
+                setStatus(`listen failed: ${messageFromError(error)}`);
+                onRequestStop();
+                exit();
+            },
+        });
         const albumAggregator = new ListenAlbumAggregator({
             emit: (group) => {
-                setScrollState((current) => applyMessageArrival(current));
-                setMessageGroups((current) => pruneListenMessageGroups([...current, group]).groups);
+                if (!isActive())
+                    return;
+                groupQueue.enqueue(group);
             },
         });
         albumAggregatorRef.current = albumAggregator;
-        const run = async () => {
-            try {
-                while (true) {
-                    setStatus('connecting...');
-                    const client = createClient();
-                    let retry = false;
-                    clientRef.current = client;
-                    if (sendTo != null) {
-                        void resolveSendTargetLabel(client, sendTo).then((label) => {
-                            if (label != null)
-                                setSendTargetLabel(label);
-                        });
+        const autoDownloader = autoDownload
+            ? new AutoDownloadCoordinator({
+                onEvent: (event) => {
+                    if (!isActive())
+                        return;
+                    const ownership = operationControllerRef.current.claimDownload(event.key);
+                    setDownloadStates((current) => applyAutoDownloadEvent(current, event, showMedia));
+                    if (event.status === 'completed' || event.status === 'failed' || event.status === 'cancelled') {
+                        ownership.release();
                     }
-                    try {
-                        const result = await client.listen({
-                            chats,
-                            signal: stopSignal,
-                            onConnected: () => setStatus('connected'),
-                            onMessage: (message) => {
-                                const key = `${message.chat_id}:${message.msg_id}`;
-                                if (seenRef.current.has(key))
-                                    return;
-                                seenRef.current.add(key);
-                                seenOrderRef.current.push(key);
-                                if (seenRef.current.size > 5000) {
-                                    const oldest = seenOrderRef.current.shift();
-                                    if (oldest != null)
-                                        seenRef.current.delete(oldest);
-                                }
-                                if (sendTo != null) {
-                                    const inferred = inferSendTargetLabel(sendTo, message);
-                                    if (inferred != null)
-                                        setSendTargetLabel(inferred);
-                                }
-                                albumAggregator.add(message);
-                            },
-                        });
-                        if (!persist || result === 'stopped') {
-                            setStatus('stopped');
-                            break;
-                        }
-                        if (result === 'disconnected') {
-                            if (!persist) {
-                                setStatus('stopped');
-                                break;
-                            }
-                            setStatus(`disconnected, retry in ${retrySeconds}s...`);
-                            retry = true;
-                        }
-                    }
-                    catch (error) {
-                        if (!persist) {
-                            setStatus(`listen failed: ${messageFromError(error)}`);
-                            break;
+                },
+            })
+            : null;
+        autoDownloaderRef.current = autoDownloader;
+        void runInteractiveAutoDownloadLifecycle({
+            autoDownload,
+            chats,
+            persist,
+            retrySeconds,
+            signal: stopSignal,
+            createClient,
+            createCoordinator: () => autoDownloader,
+            onCoordinator: (coordinator) => {
+                if (isActive())
+                    autoDownloaderRef.current = coordinator;
+            },
+            onClient: (client) => {
+                if (!isActive())
+                    return;
+                groupLookupGenerationRef.current++;
+                knownGroupRef.current = undefined;
+                setKnownGroup(undefined);
+                clientRef.current = client;
+                if (client != null && sendTo != null) {
+                    const lookup = ++groupLookupGenerationRef.current;
+                    void client.groups.getGroup(sendTo).then((group) => {
+                        if (isActive() && lookup === groupLookupGenerationRef.current && clientRef.current === client) {
+                            knownGroupRef.current = group;
+                            setKnownGroup(group);
                         }
-                        setNote(`listen failed: ${messageFromError(error)}`);
-                        retry = true;
-                    }
-                    finally {
-                        albumAggregator.flush();
-                        await client.close().catch(() => undefined);
-                        if (clientRef.current === client)
-                            clientRef.current = null;
-                    }
-                    if (retry) {
-                        await sleep(retrySeconds);
-                        continue;
-                    }
-                    break;
+                    }).catch(() => undefined);
+                    void resolveSendTargetLabel(client, sendTo).then((label) => {
+                        if (isActive() && label != null)
+                            setSendTargetLabel(label);
+                    });
                 }
-            }
-            finally {
-                if (!stopSignal.aborted) {
-                    onRequestStop();
-                    exit();
+            },
+            acceptMessage: (message) => {
+                if (!isActive())
+                    return false;
+                return acceptListenMessage(message, seenRef.current, seenOrderRef.current, () => undefined);
+            },
+            onBeforeEnqueue: (message) => {
+                if (!isActive())
+                    return;
+                registerPendingAttachmentKeys(pendingAttachmentKeysRef.current, message, showMedia);
+            },
+            onMessage: (message) => {
+                if (!isActive())
+                    return;
+                if (sendTo != null) {
+                    const inferred = inferSendTargetLabel(sendTo, message);
+                    if (inferred != null)
+                        setSendTargetLabel(inferred);
                 }
+                albumAggregator.add(message);
+            },
+            onStatus: (next) => {
+                if (!isActive())
+                    return;
+                setStatus(next === 'connecting'
+                    ? 'connecting...'
+                    : next === 'disconnected'
+                        ? `disconnected, retry in ${retrySeconds}s...`
+                        : next);
+            },
+            onError: (error) => {
+                if (!isActive())
+                    return;
+                if (persist)
+                    setNote(`listen failed: ${messageFromError(error)}`);
+                else
+                    setStatus(`listen failed: ${messageFromError(error)}`);
+            },
+            flush: () => {
+                if (isActive())
+                    albumAggregator.flush();
+            },
+        }).finally(() => {
+            if (isActive() && !stopSignal.aborted) {
+                onRequestStop();
+                exit();
             }
-        };
-        void run();
+        });
         return () => {
+            groupLookupGenerationRef.current += 1;
+            knownGroupRef.current = undefined;
             stopSignal.removeEventListener('abort', stopFromSignal);
+            albumAggregator.flush();
+            generation.dispose();
             albumAggregator.dispose();
+            void groupQueue.close();
             if (albumAggregatorRef.current === albumAggregator)
                 albumAggregatorRef.current = null;
             void clientRef.current?.close().catch(() => undefined);
             clientRef.current = null;
+            autoDownloader?.stop();
+            void autoDownloader?.waitForActive();
+            if (autoDownloaderRef.current === autoDownloader)
+                autoDownloaderRef.current = null;
         };
-    }, [chats, createClient, persist, retrySeconds, sendTo, showMedia, exit, stopSignal, onRequestStop]);
+    }, [autoDownload, chats, createClient, createReplyResolver, dbPath, persist, retrySeconds, sendTo, showMedia, exit, stopSignal, onRequestStop]);
     const sendMessage = async (text) => {
         const trimmed = text.trim();
         if (!trimmed)
             return;
+        const command = parseListenComposerInput(trimmed);
+        if (command.kind === 'error') {
+            setNote(command.error);
+            return;
+        }
         if (sendTo == null) {
             setNote('set --send-to before sending');
             return;
@@ -319,51 +944,68 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, sh
             setNote('connection is not ready');
             return;
         }
+        const isCurrent = operationControllerRef.current.beginSend();
         setInput('');
         setSending(true);
         setNote('sending...');
         try {
-            await client.sendMessage({
-                chat: sendTo,
-                message: trimmed,
-                linkPreview: true,
-            });
-            setNote('sent');
+            const sentMessages = command.kind === 'reply'
+                ? await executeListenReply(client, sendTo, command)
+                : [await client.sendMessage({
+                        chat: sendTo,
+                        message: command.content,
+                        linkPreview: true,
+                    })].flatMap(({ sent_message: message }) => message == null ? [] : [message]);
+            if (isCurrent()) {
+                for (const sentMessage of sentMessages)
+                    acceptListenMessage(sentMessage, seenRef.current, seenOrderRef.current, (message) => {
+                        registerPendingAttachmentKeys(pendingAttachmentKeysRef.current, message, showMedia);
+                        autoDownloaderRef.current?.enqueue(message);
+                        albumAggregatorRef.current?.add(message);
+                    });
+            }
+            if (isCurrent())
+                setNote(command.kind === 'reply' ? `replied to #${command.reply}` : 'sent');
         }
         catch (error) {
-            setNote(`send failed: ${messageFromError(error)}`);
+            if (isCurrent())
+                setNote(`send failed: ${messageFromError(error)}`);
         }
         finally {
-            setSending(false);
+            if (isCurrent())
+                setSending(false);
         }
     };
     const downloadAttachment = async (item) => {
-        const client = clientRef.current;
-        if (!client) {
-            setDownloadStates((current) => ({ ...current, [item.key]: { status: 'failed', error: 'not connected' } }));
-            return;
-        }
-        const destination = resolveAttachmentDestination({
-            homeDir: homedir(),
-            fileName: attachmentFileName(item),
-            exists: existsSync,
-        });
-        mkdirSync(dirname(destination), { recursive: true });
-        setDownloadStates((current) => ({ ...current, [item.key]: { status: 'downloading', progress: 0 } }));
-        try {
+        const ownership = operationControllerRef.current.beginDownload(item.key);
+        const isCurrent = ownership.isCurrent;
+        await runOwnedAttachmentOperation(ownership, async () => {
+            const client = clientRef.current;
+            if (!client)
+                throw new Error('not connected');
+            const destination = resolveAttachmentDestination({
+                homeDir: homedir(),
+                fileName: attachmentFileName(item.attachment),
+                exists: existsSync,
+            });
+            mkdirSync(dirname(destination), { recursive: true });
+            if (isCurrent())
+                setDownloadStates((current) => ({ ...current, [item.key]: { status: 'downloading', progress: 0 } }));
             await client.downloadMessageMedia({
                 ...attachmentDownloadTarget(item.attachment),
                 destination,
                 onProgress: (downloaded, total) => {
+                    if (!isCurrent())
+                        return;
                     const progress = Number.isFinite(total) && total > 0 ? Math.round(downloaded / total * 100) : null;
                     setDownloadStates((current) => ({ ...current, [item.key]: { status: 'downloading', progress } }));
                 },
             });
-            setDownloadStates((current) => ({ ...current, [item.key]: { status: 'completed', path: destination } }));
-        }
-        catch (error) {
+            if (isCurrent())
+                setDownloadStates((current) => ({ ...current, [item.key]: { status: 'completed', path: destination } }));
+        }, (error) => {
             setDownloadStates((current) => ({ ...current, [item.key]: { status: 'failed', error: messageFromError(error) } }));
-        }
+        });
     };
     const stopListening = () => {
         if (stoppingRef.current)
@@ -376,12 +1018,16 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, sh
         else
             setTimeout(exit, 0);
         onRequestStop();
+        autoDownloaderRef.current?.stop();
         clientRef.current?.close().catch(() => undefined);
     };
-    return (_jsxs(Box, { flexDirection: "row", width: terminalWidth, height: terminalHeight, overflow: "hidden", children: [_jsxs(Box, { flexDirection: "column", width: contentWidth, height: terminalHeight, overflow: "hidden", children: [_jsx(ListenStatus, { status: status, unseenCount: scrollState.unseenCount }), note ? _jsx(Text, { dimColor: true, children: note }) : null, _jsxs(Box, { marginTop: 1, flexDirection: "column", flexGrow: 1, overflow: "hidden", children: [messages.length === 0 ? _jsx(Text, { dimColor: true, children: "Waiting for new messages..." }) : null, visibleMessages.map((message) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["[", message.time, "] ", message.chatName == null ? message.sender : `${message.chatName} | ${message.sender}`] }), message.content == null ? null : _jsx(Text, { wrap: "truncate-end", children: message.content }), message.media.map((item, mediaIndex) => {
-                                        const attachmentKey = `${message.key}:${mediaIndex}`;
-                                        return (_jsx(ListenAttachmentWithPreview, { label: item.label, selected: focus === 'attachments' && selectedAttachment?.key === attachmentKey, state: downloadStates[attachmentKey] ?? { status: 'idle' }, previewCells: item.previewCells }, attachmentKey));
-                                    }), _jsx(Text, { dimColor: true, children: MESSAGE_SEPARATOR })] }, message.key)))] }), sendTo == null ? (_jsx(Text, { dimColor: true, children: "Set --send-to <chat> (or pass one chat to listen) before sending messages." })) : (_jsx(Box, { marginTop: 1, flexDirection: "column", flexShrink: 0, children: _jsx(ListenComposer, { input: input, sendTargetLabel: sendTargetLabel, terminalWidth: contentWidth, sending: sending, hint: focus === 'attachments' ? '↑/↓ select · Enter download · Tab input' : 'Enter to send · Tab attachments · Ctrl+C exit' }) }))] }), _jsx(ListenScrollbar, { height: terminalHeight, visible: scrollbarVisible, geometry: scrollbarGeometry })] }));
+    const permissionState = groupCommand.state.kind === 'select-permissions' ? groupCommand.state : null;
+    return (_jsxs(Box, { flexDirection: "row", width: terminalWidth, height: terminalHeight, overflow: "hidden", children: [_jsxs(Box, { flexDirection: "column", width: contentWidth, height: terminalHeight, overflow: "hidden", children: [_jsx(ListenStatusArea, { status: status, unseenCount: scrollState.unseenCount, autoDownload: autoDownload }), note ? _jsx(Text, { dimColor: true, children: note }) : null, groupCommand.state.kind === 'result' ? _jsx(Box, { flexGrow: 1, flexDirection: "column", children: _jsx(GroupCommandResult, { state: groupCommand.state, width: contentWidth }) }) : _jsxs(Box, { flexGrow: 1, flexDirection: "column", children: [_jsx(GroupCommandResult, { state: groupCommand.state, width: contentWidth }), groupCommand.state.kind === 'confirm' && 'confirmation' in groupCommand.state.pending ? _jsx(GroupCommandConfirm, { confirmation: groupCommand.state.pending.confirmation, selectedIndex: groupCommand.state.selectedIndex, width: contentWidth }) : null, groupCommand.state.kind === 'confirm-title' && 'confirmation' in groupCommand.state.pending ? groupCommand.state.stage === 'confirm'
+                                ? _jsx(GroupCommandConfirm, { confirmation: groupCommand.state.pending.confirmation, selectedIndex: groupCommand.state.selectedIndex, width: contentWidth })
+                                : _jsxs(Box, { flexDirection: "column", width: contentWidth, children: [_jsx(Text, { color: "yellow", children: truncateCell('Type the exact title to permanently delete this chat:', contentWidth) }), _jsx(Text, { children: truncateCell(groupCommand.state.pending.confirmation.title ?? '', contentWidth) }), _jsx(Text, { color: "#8ecbff", children: truncateCell(`› ${groupCommand.state.confirmText}`, contentWidth) }), groupCommand.state.mismatch ? _jsx(Text, { color: "red", children: truncateCell('Title does not match exactly.', contentWidth) }) : null, _jsx(Text, { dimColor: true, children: truncateCell('Enter verify · Esc back', contentWidth) })] }) : null, permissionState ? _jsxs(Box, { flexDirection: "column", width: contentWidth, children: [_jsx(Text, { color: "#8ecbff", children: truncateCell('Administrator permissions', contentWidth) }), ADMIN_RIGHT_KEYS.map((right, index) => _jsx(Text, { color: index === permissionState.selectedIndex ? '#8ecbff' : undefined, children: truncateCell(`${index === permissionState.selectedIndex ? '› ' : '  '}[${permissionState.selected.includes(right) ? 'x' : ' '}] ${right}`, contentWidth) }, right)), permissionState.warning ? _jsx(Text, { color: "yellow", children: truncateCell(permissionState.warning, contentWidth) }) : null, _jsx(Text, { dimColor: true, children: truncateCell('↑/↓ select · Space toggle · Enter continue · Esc cancel', contentWidth) })] }) : null, _jsxs(Box, { marginTop: 1, flexDirection: "column", flexGrow: 1, overflow: "hidden", children: [messages.length === 0 ? _jsx(Text, { dimColor: true, children: "Waiting for new messages..." }) : null, visibleMessages.map((message) => (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, wrap: "truncate-end", children: formatInteractiveListenHeader(message) }), message.replyContext == null ? null : _jsx(Text, { wrap: "truncate-end", children: formatReplyContext(message.replyContext) }), message.content == null ? null : _jsx(Text, { wrap: "truncate-end", children: message.content }), message.mediaSummary == null ? null : _jsx(Text, { wrap: "truncate-end", children: message.mediaSummary }), message.media.map((item, mediaIndex) => {
+                                                const attachmentKey = attachmentDownloadKeyAt(message.media, mediaIndex);
+                                                return (_jsx(ListenAttachmentWithPreview, { label: item.label, downloadable: item.downloadable, selected: focus === 'attachments' && selectedAttachment?.key === attachmentKey, state: downloadStates[attachmentKey] ?? { status: 'idle' }, previewCells: item.previewCells }, attachmentKey));
+                                            }), _jsx(Text, { dimColor: true, children: MESSAGE_SEPARATOR })] }, message.key)))] })] }), groupCommand.state.kind !== 'result' ? _jsxs(Box, { flexDirection: "column", children: [sendTo == null ? _jsx(Text, { dimColor: true, children: "Set --send-to <chat> (or pass one chat to listen) before sending messages." }) : null, _jsxs(Box, { marginTop: 1, flexDirection: "column", flexShrink: 0, children: [input.trimStart().startsWith('/') && groupCommand.state.kind === 'menu' ? _jsx(ListenCommandMenu, { input: input, selectedIndex: groupCommand.state.selectedIndex, width: contentWidth, knownGroup: knownGroup }) : null, _jsx(ListenComposer, { input: input, sendTargetLabel: sendTo == null ? '(not selected)' : sendTargetLabel, terminalWidth: contentWidth, sending: sending, hint: focus === 'attachments' ? '↑/↓ select · Enter download · Tab input' : 'Enter send · /reply <id> ... · Tab attachments · Ctrl+C exit' })] })] }) : null] }), _jsx(ListenScrollbar, { height: terminalHeight, visible: scrollbarVisible, geometry: scrollbarGeometry })] }));
 }
 export class ListenMessageViewCache {
     entries = new Map();
@@ -391,13 +1037,16 @@ export class ListenMessageViewCache {
     build(groups, context) {
         const previewWidth = normalizedPreviewWidth(context.previewWidth);
         const nextEntries = new Map();
-        const messages = groups.map((group) => {
+        const messages = groups.map((input) => {
+            const group = Array.isArray(input) ? input : input.messages;
+            const replyContext = Array.isArray(input) ? context.replyContext : input.replyContext;
             const first = group[0];
             if (first == null)
                 throw new Error('Cannot render an empty listen message group');
-            const key = `${first.chat_id}:${first.msg_id}`;
+            const key = Array.isArray(input) ? `${first.chat_id}:${first.msg_id}` : input.key;
             const cached = this.entries.get(key);
             if (cached?.group === group
+                && cached.replyContext === replyContext
                 && cached.showMedia === context.showMedia
                 && cached.previewWidth === previewWidth
                 && cached.colorDepth === context.colorDepth
@@ -405,9 +1054,10 @@ export class ListenMessageViewCache {
                 nextEntries.set(key, cached);
                 return cached.message;
             }
-            const message = toListenMessage(group, { ...context, previewWidth });
+            const message = toListenMessage(group, { ...context, previewWidth, replyContext });
             nextEntries.set(key, {
                 group,
+                replyContext,
                 showMedia: context.showMedia,
                 previewWidth,
                 colorDepth: context.colorDepth,
@@ -427,7 +1077,7 @@ export function pruneListenMessageGroups(groups, limit = LISTEN_HISTORY_LIMIT) {
     return {
         groups: groups.slice(removeCount),
         removedKeys: removed.flatMap((group) => {
-            const first = group[0];
+            const first = Array.isArray(group) ? group[0] : group.messages[0];
             return first == null ? [] : [`${first.chat_id}:${first.msg_id}`];
         }),
     };
@@ -439,8 +1089,8 @@ export function toListenMessage(messages, context) {
     const renderContext = typeof context === 'boolean'
         ? { showMedia: context, previewWidth: 1, colorDepth: 1, showChatName: false }
         : context;
-    const { showMedia, previewWidth, colorDepth, showChatName = false } = renderContext;
-    const formatted = buildListenMessage(messages, { showMedia, showChatName });
+    const { showMedia, previewWidth, colorDepth, showChatName = false, replyContext } = renderContext;
+    const formatted = buildListenMessage(messages, { showMedia, showChatName, replyContext });
     const decodePreview = renderContext.decodePreview ?? decodeImagePreview;
     const media = formatted.media.map((attachment) => {
         if (attachment.previewJpegBase64 == null || colorDepth < 24)
@@ -461,35 +1111,20 @@ export function toListenMessage(messages, context) {
 function normalizedPreviewWidth(previewWidth) {
     return Math.max(1, Math.min(24, previewWidth));
 }
-function collectAttachments(messages) {
-    return messages.flatMap((message) => message.media.map((attachment, index) => ({
-        key: `${message.key}:${index}`,
-        message,
-        attachment,
-    })));
-}
-function attachmentFileName(item) {
-    if (item.attachment.fileName != null)
-        return item.attachment.fileName;
-    const extension = MEDIA_EXTENSIONS[item.attachment.kind] ?? 'bin';
-    return `${item.attachment.chatId}-${item.attachment.messageId}.${extension}`;
-}
-export function attachmentDownloadTarget(attachment) {
-    return { chat: attachment.chatId, msgId: attachment.messageId };
+export function collectDownloadableAttachments(messages) {
+    return messages.flatMap((message) => message.media.flatMap((attachment, index) => (attachment.downloadable === true
+        ? [{
+                key: attachmentDownloadKeyAt(message.media, index),
+                message,
+                attachment,
+            }]
+        : [])));
 }
+export { attachmentDownloadTarget } from '../../services/listen-attachment.js';
 export function flushListenBeforeExit(aggregator, exit) {
     aggregator.flush();
     setTimeout(exit, 0);
 }
-const MEDIA_EXTENSIONS = {
-    Photo: 'jpg',
-    Video: 'mp4',
-    Audio: 'mp3',
-    Voice: 'ogg',
-    Sticker: 'webp',
-    Animation: 'mp4',
-    Document: 'bin',
-};
 function messageFromError(error) {
     return error instanceof Error ? error.message : String(error);
 }