@will-17173/telegram-cli 0.2.0 → 0.4.0

package/dist/presenters/ink/listen.js

@@ -5,7 +5,7 @@ import stringWidth from 'string-width';
 import { existsSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname } from 'node:path';
-import { resolveAttachmentDestination } from '../../services/attachment-download.js';
+import { attachmentDownloadProgress, 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';
@@ -13,8 +13,24 @@ import { buildListenMessage } from '../listen-message.js';
 import { applyMessageArrival, applyScroll, 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 { isMouseInput, withAlternateScroll } 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 { WriteAccessPolicy } from '../../services/write-access-policy.js';
+import { GroupCommandConfirm } from './group-command-confirm.js';
+import { truncateCell } from './display-width.js';
+import { SecureInput } from './secure-input.js';
 const MESSAGE_SEPARATOR = '────────────────────────────────────────────';
+const OWNERSHIP_SHUTDOWN_GRACE_MS = 250;
 /** Maximum number of grouped messages retained by a long-running interactive listener. */
 export const LISTEN_HISTORY_LIMIT = 500;
 const LISTEN_IMAGE_PREVIEWS_ENABLED = false;
@@ -47,11 +63,14 @@ export const LISTEN_COMPOSER_THEME = {
     target: '#f0d38a',
     hint: '#9bdca8',
 };
-export function ListenComposer({ input, sendTargetLabel, terminalWidth, sending = false, hint = 'Enter to send · Ctrl+C to exit', }) {
+export function listenComposerCursorColor(visible) {
+    return visible ? LISTEN_COMPOSER_THEME.cursor : LISTEN_COMPOSER_THEME.background;
+}
+export function ListenComposer({ input, sendTargetLabel, terminalWidth, sending = false, hint = 'Enter to send · Ctrl+C to exit', cursorVisible = true, }) {
     const inputText = `› ${input}${sending ? ' (sending...)' : ''}`;
     const blankRow = ' '.repeat(Math.max(0, terminalWidth));
     const inputRowFill = ' '.repeat(Math.max(0, terminalWidth - stringWidth(inputText) - 1));
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { backgroundColor: LISTEN_COMPOSER_THEME.background, children: blankRow }), _jsxs(Text, { backgroundColor: LISTEN_COMPOSER_THEME.background, color: LISTEN_COMPOSER_THEME.foreground, children: [inputText, _jsx(Text, { backgroundColor: LISTEN_COMPOSER_THEME.cursor, children: " " }), inputRowFill] }), _jsx(Text, { backgroundColor: LISTEN_COMPOSER_THEME.background, children: blankRow }), _jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { color: LISTEN_COMPOSER_THEME.target, children: ["To: ", sendTargetLabel] }), _jsx(Text, { color: LISTEN_COMPOSER_THEME.hint, children: hint })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { backgroundColor: LISTEN_COMPOSER_THEME.background, children: blankRow }), _jsxs(Text, { backgroundColor: LISTEN_COMPOSER_THEME.background, color: LISTEN_COMPOSER_THEME.foreground, children: [inputText, _jsx(Text, { backgroundColor: listenComposerCursorColor(cursorVisible), children: " " }), inputRowFill] }), _jsx(Text, { backgroundColor: LISTEN_COMPOSER_THEME.background, children: blankRow }), _jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { color: LISTEN_COMPOSER_THEME.target, children: ["To: ", sendTargetLabel] }), _jsx(Text, { color: LISTEN_COMPOSER_THEME.hint, children: hint })] })] }));
 }
 export function ListenAttachmentLine({ label, selected, state }) {
     const action = state.status === 'idle'
@@ -183,16 +202,23 @@ export async function runInteractiveAutoDownloadLifecycle(options) {
         : null;
     options.onCoordinator?.(coordinator);
     let currentClient = null;
+    let closeCurrentClient = null;
     const abort = () => {
         coordinator?.stop();
-        void currentClient?.close().catch(() => undefined);
+        void closeCurrentClient?.();
     };
     options.signal.addEventListener('abort', abort);
     try {
         while (!options.signal.aborted) {
             options.onStatus?.('connecting');
             const client = options.createClient();
+            let closePromise;
+            const closeClient = () => {
+                closePromise ??= Promise.resolve().then(() => client.close()).catch(() => undefined);
+                return closePromise;
+            };
             currentClient = client;
+            closeCurrentClient = closeClient;
             options.onClient?.(client);
             coordinator?.setClient(client);
             let retry = false;
@@ -236,11 +262,13 @@ export async function runInteractiveAutoDownloadLifecycle(options) {
                 else {
                     coordinator?.stop();
                 }
-                await client.close().catch(() => undefined);
+                await closeClient();
                 if (options.signal.aborted)
                     await coordinator?.waitForActive();
                 if (currentClient === client)
                     currentClient = null;
+                if (closeCurrentClient === closeClient)
+                    closeCurrentClient = null;
                 options.onClient?.(null);
             }
             if (!retry)
@@ -268,6 +296,81 @@ export function ListenAttachmentWithPreview({ label, downloadable = true, select
                 ? _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` : ''] });
 }
@@ -277,6 +380,9 @@ export function formatInteractiveListenSender(message) {
         : `${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] }));
 }
@@ -285,7 +391,7 @@ export function calculateListenMessagePaneHeight(terminalHeight, hasNote, autoDo
     return Math.max(2, terminalHeight - reservedLines);
 }
 export async function runInteractiveListen(write, run) {
-    return withMouseReporting({ write, run });
+    return withAlternateScroll({ write, run });
 }
 export async function renderInteractiveListen(options) {
     await runInteractiveListen(process.stdout.write.bind(process.stdout), async () => {
@@ -293,7 +399,7 @@ export async function renderInteractiveListen(options) {
         await app.waitUntilExit();
     });
 }
-function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, autoDownload, showChatName, createClient, stopSignal, onRequestStop, }) {
+export function InteractiveListen({ dbPath, chats, persist, retrySeconds, sendTo, showMedia, autoDownload, showChatName, createClient, stopSignal, onRequestStop, createReplyResolver, shutdownRequests, }) {
     const { exit } = useApp();
     const { stdout } = useStdout();
     const terminalMetrics = useTerminalMetrics(stdout);
@@ -307,23 +413,88 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, au
     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({});
+    const commandSelectionRef = useRef(0);
+    const knownGroupRef = useRef(undefined);
+    const groupLookupGenerationRef = useRef({});
+    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;
+        const refreshOwnershipCapability = request.key === 'admin transfer-owner'
+            && options?.confirmed === true
+            && options.ownershipPassword == null;
+        if (knownGroup == null || refreshOwnershipCapability) {
+            const lookup = {};
+            groupLookupGenerationRef.current = lookup;
+            knownGroup = await client.groups.getGroup(sendTo);
+            if (lookup !== groupLookupGenerationRef.current || clientRef.current !== client) {
+                return { ok: false, error: { code: 'connection_not_ready', message: 'Telegram connection changed during group verification.' } };
+            }
+            knownGroupRef.current = knownGroup;
+            setKnownGroup(knownGroup);
+        }
+        return executeGroupCommand(request, {
+            chat: sendTo,
+            groups: new GroupWriteService(client.groups),
+            confirmed: options?.confirmed ?? false,
+            confirmationTitle: options?.confirmationTitle,
+            ownershipPassword: options?.ownershipPassword,
+            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 = lookup;
+                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 irreversibleGroupWriteRef = useRef(false);
+    irreversibleGroupWriteRef.current = groupCommand.state.kind === 'executing' && groupCommand.state.irreversible === true;
     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 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());
@@ -331,6 +502,37 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, au
     if (operationControllerRef.current == null)
         operationControllerRef.current = createInteractiveOperationController();
     const stoppingRef = useRef(false);
+    const lifecycleStopRef = useRef(null);
+    const deferredStopRef = useRef(false);
+    const shutdownRequestedRef = useRef(false);
+    const shutdownGraceTimerRef = useRef(null);
+    function requestOwnershipShutdown(source) {
+        if (deferredStopRef.current || shutdownRequestedRef.current) {
+            deferredStopRef.current = false;
+            shutdownRequestedRef.current = false;
+            if (shutdownGraceTimerRef.current)
+                clearTimeout(shutdownGraceTimerRef.current);
+            shutdownGraceTimerRef.current = null;
+            groupCommand.setState({ kind: 'error', message: 'Ownership transfer outcome is indeterminate after forced shutdown.' });
+            setTimeout(stopListening, 0);
+            return;
+        }
+        if (source === 'terminal') {
+            deferredStopRef.current = true;
+            setNote('Group write is already running; wait for its outcome.');
+            return;
+        }
+        shutdownRequestedRef.current = true;
+        setNote('Shutdown requested; waiting briefly for the ownership transfer outcome.');
+        shutdownGraceTimerRef.current = setTimeout(() => {
+            shutdownGraceTimerRef.current = null;
+            groupCommand.setState({
+                kind: 'error',
+                message: 'Ownership transfer outcome is indeterminate because shutdown grace expired.',
+            });
+            setTimeout(stopListening, 0);
+        }, OWNERSHIP_SHUTDOWN_GRACE_MS);
+    }
     const seenRef = useRef(new Set());
     const seenOrderRef = useRef([]);
     const downloadableAttachments = collectDownloadableAttachments(visibleMessages);
@@ -342,11 +544,10 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, au
         visible: visibleMessages.length,
         offset: scrollState.offset,
     });
-    const handleMouseScroll = useCallback((direction) => {
+    const scrollMessages = useCallback((direction, amount = 1) => {
         showScrollbar();
-        setScrollState((current) => applyScroll(current, direction, Math.max(0, messages.length - 1)));
+        setScrollState((current) => applyScroll(current, direction, Math.max(0, messages.length - 1), amount));
     }, [messages.length, showScrollbar]);
-    useMouseScroll(handleMouseScroll);
     useEffect(() => {
         const maxOffset = Math.max(0, messages.length - 1);
         setScrollState((current) => {
@@ -369,10 +570,160 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, au
     useInput((inputText, key) => {
         if (isMouseInput(inputText))
             return;
+        const modal = groupCommand.state;
+        if (modal.kind === 'executing' && modal.irreversible === true) {
+            if (key.ctrl && (inputText === 'c' || inputText === 'C' || inputText === '\u0003')) {
+                requestOwnershipShutdown('terminal');
+            }
+            else if (key.escape) {
+                setNote('Group write is already running; wait for its outcome.');
+            }
+            return;
+        }
         if (key.ctrl && (inputText === 'c' || inputText === 'C' || inputText === '\u0003')) {
             stopListening();
             return;
         }
+        if (modal.kind === 'password')
+            return;
+        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 = lookup;
+                    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;
+        }
+        if (replyExecutionLockRef.current) {
+            if (key.escape)
+                setNote('Reply is still sending; wait for its outcome.');
+            return;
+        }
+        if (key.pageUp || key.pageDown) {
+            scrollMessages(key.pageUp ? 'up' : 'down', Math.max(1, visibleMessages.length));
+            return;
+        }
+        const slashMode = input.trimStart().startsWith('/');
+        if (slashMode && key.escape) {
+            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');
@@ -406,13 +757,95 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, au
             }
             return;
         }
-        if (sending)
+        if (key.upArrow || key.downArrow) {
+            scrollMessages(key.upArrow ? 'up' : 'down');
+            return;
+        }
+        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;
+                    }
+                    const access = new WriteAccessPolicy().check();
+                    if (!access.ok) {
+                        setNote(access.error.message);
+                        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;
         }
@@ -420,26 +853,58 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, au
             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;
+        const lifecycleStop = new AbortController();
+        lifecycleStopRef.current = lifecycleStop;
         if (stopSignal.aborted) {
             exit();
             return;
         }
         const stopFromSignal = () => {
+            if (stoppingRef.current)
+                return;
+            if (irreversibleGroupWriteRef.current) {
+                requestOwnershipShutdown('external');
+                return;
+            }
             stopListening();
         };
-        stopSignal.addEventListener('abort', stopFromSignal);
+        const unsubscribeShutdown = shutdownRequests?.subscribe(stopFromSignal);
+        if (shutdownRequests == null)
+            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) => {
                 if (!isActive())
                     return;
-                setScrollState((current) => applyMessageArrival(current));
-                setMessageGroups((current) => pruneListenMessageGroups([...current, group]).groups);
+                groupQueue.enqueue(group);
             },
         });
         albumAggregatorRef.current = albumAggregator;
@@ -462,7 +927,7 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, au
             chats,
             persist,
             retrySeconds,
-            signal: stopSignal,
+            signal: lifecycleStop.signal,
             createClient,
             createCoordinator: () => autoDownloader,
             onCoordinator: (coordinator) => {
@@ -472,8 +937,19 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, au
             onClient: (client) => {
                 if (!isActive())
                     return;
+                groupLookupGenerationRef.current = {};
+                knownGroupRef.current = undefined;
+                setKnownGroup(undefined);
                 clientRef.current = client;
                 if (client != null && sendTo != null) {
+                    const lookup = {};
+                    groupLookupGenerationRef.current = lookup;
+                    void client.groups.getGroup(sendTo).then((group) => {
+                        if (isActive() && lookup === groupLookupGenerationRef.current && clientRef.current === client) {
+                            knownGroupRef.current = group;
+                            setKnownGroup(group);
+                        }
+                    }).catch(() => undefined);
                     void resolveSendTargetLabel(client, sendTo).then((label) => {
                         if (isActive() && label != null)
                             setSendTargetLabel(label);
@@ -522,29 +998,50 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, au
                     albumAggregator.flush();
             },
         }).finally(() => {
-            if (isActive() && !stopSignal.aborted) {
+            if (isActive() && !stopSignal.aborted && !stoppingRef.current) {
                 onRequestStop();
                 exit();
             }
         });
         return () => {
+            groupLookupGenerationRef.current = {};
+            knownGroupRef.current = undefined;
+            unsubscribeShutdown?.();
+            if (shutdownRequests == null)
+                stopSignal.removeEventListener('abort', stopFromSignal);
+            albumAggregator.flush();
             generation.dispose();
-            stopSignal.removeEventListener('abort', stopFromSignal);
             albumAggregator.dispose();
+            void groupQueue.close();
             if (albumAggregatorRef.current === albumAggregator)
                 albumAggregatorRef.current = null;
-            void clientRef.current?.close().catch(() => undefined);
+            lifecycleStop.abort();
             clientRef.current = null;
             autoDownloader?.stop();
             void autoDownloader?.waitForActive();
             if (autoDownloaderRef.current === autoDownloader)
                 autoDownloaderRef.current = null;
+            if (lifecycleStopRef.current === lifecycleStop)
+                lifecycleStopRef.current = null;
+            if (shutdownGraceTimerRef.current)
+                clearTimeout(shutdownGraceTimerRef.current);
+            shutdownGraceTimerRef.current = null;
         };
-    }, [autoDownload, chats, createClient, persist, retrySeconds, sendTo, showMedia, exit, stopSignal, onRequestStop]);
+    }, [autoDownload, chats, createClient, createReplyResolver, dbPath, persist, retrySeconds, sendTo, showMedia, exit, stopSignal, shutdownRequests, onRequestStop]);
     const sendMessage = async (text) => {
+        const access = new WriteAccessPolicy().check();
+        if (!access.ok) {
+            setNote(access.error.message);
+            return;
+        }
         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;
@@ -559,20 +1056,23 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, au
         setSending(true);
         setNote('sending...');
         try {
-            const result = await client.sendMessage({
-                chat: sendTo,
-                message: trimmed,
-                linkPreview: true,
-            });
-            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);
-                });
+            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('sent');
+                setNote(command.kind === 'reply' ? `replied to #${command.reply}` : 'sent');
         }
         catch (error) {
             if (isCurrent())
@@ -604,7 +1104,7 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, au
                 onProgress: (downloaded, total) => {
                     if (!isCurrent())
                         return;
-                    const progress = Number.isFinite(total) && total > 0 ? Math.round(downloaded / total * 100) : null;
+                    const progress = attachmentDownloadProgress(downloaded, total);
                     setDownloadStates((current) => ({ ...current, [item.key]: { status: 'downloading', progress } }));
                 },
             });
@@ -626,12 +1126,28 @@ function InteractiveListen({ chats, persist, retrySeconds, sendTo, showMedia, au
             setTimeout(exit, 0);
         onRequestStop();
         autoDownloaderRef.current?.stop();
-        clientRef.current?.close().catch(() => undefined);
+        lifecycleStopRef.current?.abort();
     };
-    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 })] }));
+    useEffect(() => {
+        if (groupCommand.state.kind !== 'result' && groupCommand.state.kind !== 'error')
+            return;
+        if (!deferredStopRef.current && !shutdownRequestedRef.current)
+            return;
+        deferredStopRef.current = false;
+        shutdownRequestedRef.current = false;
+        if (shutdownGraceTimerRef.current)
+            clearTimeout(shutdownGraceTimerRef.current);
+        shutdownGraceTimerRef.current = null;
+        const pending = setTimeout(stopListening, 0);
+        return () => clearTimeout(pending);
+    }, [groupCommand.state]);
+    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, groupCommand.state.kind === 'password' ? _jsx(SecureInput, { label: "Telegram 2FA password", onSubmit: (value) => { void groupCommand.runWithOwnershipPassword(value); }, onCancel: closeGroupCommand }) : 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, cursorVisible: focus === 'input', hint: focus === 'attachments' ? '↑/↓ select · Enter download · Tab input' : 'Wheel/↑/↓/PgUp/PgDn scroll · Drag select · Ctrl+C exit' })] })] }) : null] }), _jsx(ListenScrollbar, { height: terminalHeight, visible: scrollbarVisible, geometry: scrollbarGeometry })] }));
 }
 export class ListenMessageViewCache {
     entries = new Map();
@@ -641,13 +1157,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
@@ -655,9 +1174,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,
@@ -677,7 +1197,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}`];
         }),
     };
@@ -689,8 +1209,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)