@will-17173/telegram-cli 0.1.1 → 0.2.0

package/dist/presenters/ink/listen.js

@@ -7,6 +7,8 @@ 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 { decodeImagePreview } from './image-preview.js';
@@ -54,22 +56,234 @@ 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 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 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 });
 }
@@ -79,7 +293,7 @@ export async function renderInteractiveListen(options) {
         await app.waitUntilExit();
     });
 }
-function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, showChatName, createClient, stopSignal, onRequestStop, }) {
+function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, autoDownload, showChatName, createClient, stopSignal, onRequestStop, }) {
     const { exit } = useApp();
     const { stdout } = useStdout();
     const terminalMetrics = useTerminalMetrics(stdout);
@@ -107,15 +321,19 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, sh
         colorDepth: previewColorDepth,
         showChatName,
     }), [messageGroups, showMedia, previewWidth, previewColorDepth, showChatName]);
-    const reservedLines = 7 + (note ? 1 : 0);
-    const messagePaneHeight = Math.max(2, terminalHeight - reservedLines);
+    const messagePaneHeight = calculateListenMessagePaneHeight(terminalHeight, note.length > 0, autoDownload);
     const visibleMessages = takeListenViewport(messages, messagePaneHeight, scrollState.offset);
     const clientRef = useRef(null);
     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 scrollbarGeometry = calculateScrollbar({
@@ -138,11 +356,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');
@@ -181,7 +400,9 @@ 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;
         }
@@ -203,6 +424,8 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, sh
         }
     });
     useEffect(() => {
+        const generation = operationControllerRef.current.beginGeneration();
+        const isActive = generation.isActive;
         if (stopSignal.aborted) {
             exit();
             return;
@@ -213,99 +436,111 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, sh
         stopSignal.addEventListener('abort', stopFromSignal);
         const albumAggregator = new ListenAlbumAggregator({
             emit: (group) => {
+                if (!isActive())
+                    return;
                 setScrollState((current) => applyMessageArrival(current));
                 setMessageGroups((current) => pruneListenMessageGroups([...current, group]).groups);
             },
         });
         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;
-                        }
-                        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;
+                },
+            })
+            : 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;
+                clientRef.current = client;
+                if (client != null && sendTo != null) {
+                    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 () => {
+            generation.dispose();
             stopSignal.removeEventListener('abort', stopFromSignal);
             albumAggregator.dispose();
             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, persist, retrySeconds, sendTo, showMedia, exit, stopSignal, onRequestStop]);
     const sendMessage = async (text) => {
         const trimmed = text.trim();
         if (!trimmed)
@@ -319,51 +554,65 @@ 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({
+            const result = await client.sendMessage({
                 chat: sendTo,
                 message: trimmed,
                 linkPreview: true,
             });
-            setNote('sent');
+            if (isCurrent() && result.sent_message != null) {
+                acceptListenMessage(result.sent_message, seenRef.current, seenOrderRef.current, (message) => {
+                    registerPendingAttachmentKeys(pendingAttachmentKeysRef.current, message, showMedia);
+                    autoDownloaderRef.current?.enqueue(message);
+                    albumAggregatorRef.current?.add(message);
+                });
+            }
+            if (isCurrent())
+                setNote('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,11 +625,12 @@ 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));
+    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, _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, "] ", formatInteractiveListenSender(message)] }), message.content == null ? null : _jsx(Text, { wrap: "truncate-end", children: message.content }), 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)))] }), 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 })] }));
 }
 export class ListenMessageViewCache {
@@ -461,35 +711,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);
 }