@ask-thane/thane-cli 0.1.2 → 0.1.6

package/dist/chat.js

@@ -1,195 +1,526 @@
-import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
-import { runSlashMenu } from "./menu.js";
-import { renderInbox, renderMessages, renderUsers, renderWorkspaces } from "./render.js";
+import { emitKeypressEvents } from "node:readline";
 import { completeSlashCommand, renderSlashCommands, slashCommands } from "./slash-commands.js";
 import { ThaneStore } from "./store.js";
-async function selectChannel(store, target) {
+const CLEAR = "\x1b[2J\x1b[H";
+const HIDE_CURSOR = "\x1b[?25l";
+const SHOW_CURSOR = "\x1b[?25h";
+const RESET = "\x1b[0m";
+const DIM = "\x1b[2m";
+const INVERSE = "\x1b[7m";
+const BOLD = "\x1b[1m";
+function size() {
+    return {
+        columns: Math.max(60, Number(output.columns ?? 100)),
+        rows: Math.max(20, Number(output.rows ?? 30))
+    };
+}
+function stripAnsi(value) {
+    return value.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
+}
+function visibleLength(value) {
+    return stripAnsi(value).length;
+}
+function fit(value, width) {
+    const plain = stripAnsi(value);
+    if (plain.length <= width) {
+        return value + " ".repeat(width - plain.length);
+    }
+    return `${plain.slice(0, Math.max(0, width - 1))}…`;
+}
+function wrap(value, width) {
+    if (width <= 0) {
+        return [""];
+    }
+    const words = value.split(/\s+/);
+    const lines = [];
+    let line = "";
+    for (const word of words) {
+        if (!line) {
+            line = word;
+        }
+        else if (line.length + word.length + 1 <= width) {
+            line = `${line} ${word}`;
+        }
+        else {
+            lines.push(line);
+            line = word;
+        }
+        while (line.length > width) {
+            lines.push(line.slice(0, width));
+            line = line.slice(width);
+        }
+    }
+    if (line) {
+        lines.push(line);
+    }
+    return lines.length ? lines : [""];
+}
+function channelLabel(channel) {
+    return channel.kind === "dm" ? `@${channel.name}` : `#${channel.name}`;
+}
+function conversations(store, activeId) {
+    const activity = new Map(store.inbox({ includeQuiet: true }).map((summary) => [summary.conversationId, summary]));
+    const channels = store.listChannels().map((channel) => {
+        const summary = activity.get(channel.id);
+        return {
+            id: channel.id,
+            label: channelLabel(channel),
+            name: channel.name,
+            kind: channel.kind,
+            unreadCount: summary?.unreadCount ?? 0,
+            mentionCount: summary?.mentionCount ?? 0
+        };
+    });
+    const dms = store.listDms().map((dm) => {
+        const summary = activity.get(dm.id);
+        return {
+            id: dm.id,
+            label: channelLabel(dm),
+            name: dm.name,
+            kind: dm.kind,
+            unreadCount: summary?.unreadCount ?? 0,
+            mentionCount: summary?.mentionCount ?? 0
+        };
+    });
+    const all = [...channels, ...dms];
+    if (!all.some((item) => item.id === activeId)) {
+        const channel = store.findChannel(activeId);
+        if (channel) {
+            all.unshift({
+                id: channel.id,
+                label: channelLabel(channel),
+                name: channel.name,
+                kind: channel.kind,
+                unreadCount: 0,
+                mentionCount: 0
+            });
+        }
+    }
+    return all;
+}
+async function selectConversation(store, target) {
     if (target.startsWith("@")) {
-        const dm = await store.findOrCreateDm(target.slice(1));
-        return { channelId: dm.id, promptName: `@${dm.name}` };
+        return store.findOrCreateDm(target.slice(1));
+    }
+    return store.createChannel(target.replace(/^#/, ""));
+}
+function renderMessage(message, width) {
+    const date = new Date(message.createdAt);
+    const time = Number.isNaN(date.getTime())
+        ? message.createdAt
+        : date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+    const prefix = `${DIM}${time}${RESET} ${BOLD}${message.author}${RESET}: `;
+    const bodyWidth = Math.max(10, width - visibleLength(prefix));
+    const lines = wrap(message.text, bodyWidth);
+    return lines.map((line, index) => (index === 0 ? `${prefix}${line}` : `${" ".repeat(visibleLength(prefix))}${line}`));
+}
+function commandMatches(inputText) {
+    if (!inputText.startsWith("/")) {
+        return [];
+    }
+    const [names] = completeSlashCommand(inputText);
+    return names
+        .map((name) => slashCommands.find((command) => command.name === name))
+        .filter((command) => Boolean(command));
+}
+function replaceTrailingToken(inputText, value) {
+    const match = inputText.match(/(^|\s)(\S*)$/);
+    if (!match || match.index === undefined) {
+        return value;
     }
-    const channel = await store.createChannel(target);
-    return { channelId: channel.id, promptName: `#${channel.name}` };
+    const start = match.index + (match[1]?.length ?? 0);
+    return `${inputText.slice(0, start)}${value}`;
+}
+function completionCandidates(store, inputText) {
+    if (inputText.startsWith("/join ")) {
+        const prefix = inputText.slice("/join ".length).replace(/^#/, "").toLowerCase();
+        return store
+            .listChannels()
+            .filter((channel) => channel.name.startsWith(prefix))
+            .map((channel) => ({ label: `#${channel.name}`, value: `/join ${channel.name}` }));
+    }
+    if (inputText.startsWith("/workspace ")) {
+        const prefix = inputText.slice("/workspace ".length).toLowerCase();
+        return store
+            .listWorkspaces()
+            .filter((workspace) => workspace.slug.startsWith(prefix))
+            .map((workspace) => ({ label: workspace.slug, value: `/workspace ${workspace.slug}` }));
+    }
+    if (inputText.startsWith("/dm ")) {
+        const prefix = inputText.slice("/dm ".length).replace(/^@/, "").toLowerCase();
+        return store
+            .listUsers()
+            .filter((user) => user.handle.startsWith(prefix) && user.id !== store.currentUser.id)
+            .map((user) => ({ label: `@${user.handle}`, value: `/dm ${user.handle}` }));
+    }
+    const trailingMention = inputText.match(/(^|\s)@([a-z0-9._-]*)$/i);
+    if (trailingMention) {
+        const prefix = trailingMention[2]?.toLowerCase() ?? "";
+        return store
+            .listUsers()
+            .filter((user) => user.handle.startsWith(prefix))
+            .map((user) => ({ label: `@${user.handle}`, value: replaceTrailingToken(inputText, `@${user.handle}`) }));
+    }
+    return commandMatches(inputText).map((command) => ({
+        label: command.usage,
+        value: commandInput(command)
+    }));
+}
+function renderMenuLines(selectedIndex, availableRows) {
+    const visibleRows = Math.max(1, availableRows - 4);
+    const start = Math.max(0, Math.min(selectedIndex - Math.floor(visibleRows / 2), slashCommands.length - visibleRows));
+    const visibleCommands = slashCommands.slice(start, start + visibleRows);
+    return [
+        `${BOLD}Command Menu${RESET}`,
+        `${DIM}Use arrows, Return to choose, Esc to close.${RESET}`,
+        "",
+        ...visibleCommands.map((command, index) => {
+            const actualIndex = start + index;
+            const pointer = actualIndex === selectedIndex ? "> " : "  ";
+            const row = `${pointer}${command.usage.padEnd(26)} ${command.description}`;
+            return actualIndex === selectedIndex ? `${INVERSE}${row}${RESET}` : row;
+        })
+    ];
+}
+function commandInput(command) {
+    return command.needsArgument ? `${command.name} ` : command.name;
+}
+function renderScreen(inputText, state) {
+    const { columns, rows } = size();
+    const sidebarWidth = Math.min(32, Math.max(24, Math.floor(columns * 0.28)));
+    const mainWidth = columns - sidebarWidth - 1;
+    const contentRows = rows - 4;
+    const active = state.store.findChannel(state.activeChannelId);
+    const items = conversations(state.store, state.activeChannelId);
+    const messages = state.store.recent(state.activeChannelId, 200);
+    const lines = [];
+    lines.push(`${CLEAR}${HIDE_CURSOR}${BOLD}Thane Chat${RESET} ${DIM}${state.store.activeWorkspace.slug}${RESET}`);
+    lines.push(`${"─".repeat(columns)}`);
+    const renderedMessages = messages.flatMap((message) => renderMessage(message, mainWidth - 2));
+    const helpLines = state.showMenu
+        ? renderMenuLines(state.menuIndex, contentRows)
+        : state.showHelp
+            ? [
+                `${BOLD}Commands${RESET}`,
+                "/join <channel>   /dm <handle>   /workspace <slug>",
+                "/commands         /help          /quit",
+                "",
+                ...renderSlashCommands().split("\n").slice(0, Math.max(0, contentRows - 5))
+            ]
+            : renderedMessages.slice(-contentRows);
+    for (let row = 0; row < contentRows; row += 1) {
+        const item = items[row];
+        let left = "";
+        if (item) {
+            const unread = item.unreadCount > 0 ? ` ${item.unreadCount}` : "";
+            const mention = item.mentionCount > 0 ? " @" : "";
+            const marker = item.id === state.activeChannelId ? ">" : " ";
+            left = `${marker} ${item.label}${mention}${unread}`;
+            if (item.id === state.activeChannelId) {
+                left = `${INVERSE}${fit(left, sidebarWidth)}${RESET}`;
+            }
+            else {
+                left = fit(left, sidebarWidth);
+            }
+        }
+        else {
+            left = " ".repeat(sidebarWidth);
+        }
+        const right = fit(helpLines[row] ?? "", mainWidth - 1);
+        lines.push(`${left}│${right}`);
+    }
+    const matches = state.showMenu ? [] : completionCandidates(state.store, inputText).slice(0, 4);
+    const suggestionStatus = matches.length > 0
+        ? `${DIM}Tab completes:${RESET} ${matches.map((candidate) => candidate.label).join("  ")}`
+        : "";
+    const status = suggestionStatus || state.status || `${active ? channelLabel(active) : "conversation"}  ${DIM}Enter sends. Up/down recalls input. Alt+up/down switches. /menu opens menu.${RESET}`;
+    lines.push(`${"─".repeat(columns)}`);
+    lines.push(fit(status, columns));
+    lines.push(fit(`> ${inputText}`, columns));
+    output.write(lines.join("\n"));
 }
 export async function runChat(initialChannel = "general") {
     let store = await ThaneStore.open();
-    let { channelId: channel, promptName } = await selectChannel(store, initialChannel);
-    let lastSeenAt = store.recent(channel, 50).at(-1)?.createdAt ?? "";
-    let lastActivitySignature = "";
-    const rl = createInterface({
-        input,
-        output,
-        prompt: `${store.activeWorkspace.slug}${promptName}> `,
-        completer: completeSlashCommand
-    });
+    let activeChannel = await selectConversation(store, initialChannel);
+    let inputText = "";
+    let status = "";
+    let showHelp = false;
+    let showMenu = false;
+    let menuIndex = 0;
+    const inputHistory = [];
+    let historyIndex;
+    let draftInput = "";
     let isOpen = true;
-    const poll = setInterval(() => {
-        void (async () => {
-            if (!isOpen) {
-                return;
-            }
-            const freshStore = await ThaneStore.open();
-            const freshMessages = freshStore.recent(channel, 50).filter((message) => message.createdAt > lastSeenAt);
-            if (freshMessages.length === 0) {
-                store = freshStore;
-                const activity = freshStore
-                    .inbox({ allWorkspaces: true, onlyUnread: true })
-                    .filter((summary) => !(summary.workspaceId === freshStore.activeWorkspace.id && summary.conversationId === channel));
-                const signature = JSON.stringify(activity.map((summary) => [summary.workspaceId, summary.conversationId, summary.unreadCount, summary.mentionCount]));
-                if (activity.length > 0 && signature !== lastActivitySignature) {
-                    lastActivitySignature = signature;
-                    output.write(`\nActivity elsewhere:\n${renderInbox(activity)}\n`);
-                    rl.prompt();
-                }
-                return;
-            }
-            lastSeenAt = freshMessages.at(-1)?.createdAt ?? lastSeenAt;
-            store = freshStore;
-            output.write(`\n${renderMessages(freshMessages)}\n`);
-            rl.prompt();
-        })().catch((error) => {
-            output.write(`\n${error.message}\n`);
-            rl.prompt();
-        });
-    }, 2_000);
-    output.write(`Thane chat - workspace ${store.activeWorkspace.slug}\n`);
-    output.write("Type /commands to see commands, /menu for an arrow-key menu, or press Tab after / for completion.\n\n");
-    output.write(`${renderMessages(store.recent(channel, 20))}\n\n`);
-    rl.prompt();
-    const runSlashLine = async (trimmed) => {
-        if (trimmed === "/quit" || trimmed === "/exit") {
-            return "quit";
-        }
-        if (trimmed === "/commands") {
-            output.write(`${renderSlashCommands()}\n`);
-        }
-        else if (trimmed === "/menu") {
-            rl.pause();
-            const selected = await runSlashMenu(slashCommands);
-            rl.resume();
-            if (selected) {
-                if (selected.needsArgument) {
-                    output.write(`${selected.usage} - ${selected.description}\n`);
-                }
-                else {
-                    return runSlashLine(selected.name);
-                }
-            }
+    const refresh = async () => {
+        store = await ThaneStore.open();
+        renderScreen(inputText, { store, activeChannelId: activeChannel.id, status, showHelp, showMenu, menuIndex });
+    };
+    const switchTo = async (conversationId) => {
+        const channel = store.findChannel(conversationId);
+        if (!channel) {
+            return;
         }
-        else if (trimmed === "/inbox") {
-            output.write(`${renderInbox(store.inbox({ onlyUnread: true }))}\n`);
+        activeChannel = channel;
+        showHelp = false;
+        showMenu = false;
+        status = `Switched to ${channelLabel(channel)}`;
+        await store.markReadConversation(activeChannel.id);
+        await refresh();
+    };
+    const switchConversation = async (direction) => {
+        const items = conversations(store, activeChannel.id);
+        const index = Math.max(0, items.findIndex((item) => item.id === activeChannel.id));
+        const next = items[(index + direction + items.length) % items.length];
+        if (next) {
+            await switchTo(next.id);
         }
-        else if (trimmed === "/inbox all") {
-            output.write(`${renderInbox(store.inbox({ allWorkspaces: true, onlyUnread: true }))}\n`);
+    };
+    const rememberInput = (line) => {
+        if (!line.trim()) {
+            return;
         }
-        else if (trimmed === "/workspaces") {
-            output.write(`${renderWorkspaces(store.listWorkspaces(), store.activeWorkspace.id)}\n`);
+        if (inputHistory[inputHistory.length - 1] !== line) {
+            inputHistory.push(line);
         }
-        else if (trimmed.startsWith("/workspace ")) {
-            const workspace = await store.useWorkspace(trimmed.slice("/workspace ".length).trim());
-            ({ channelId: channel, promptName } = await selectChannel(store, "general"));
-            lastSeenAt = store.recent(channel, 50).at(-1)?.createdAt ?? "";
-            lastActivitySignature = "";
-            rl.setPrompt(`${workspace.slug}${promptName}> `);
-            output.write(`${renderMessages(store.recent(channel, 20))}\n`);
-        }
-        else if (trimmed === "/channels") {
-            output.write(`${store.listChannels().map((item) => `#${item.name}`).join("\n")}\n`);
-        }
-        else if (trimmed.startsWith("/join ")) {
-            ({ channelId: channel, promptName } = await selectChannel(store, trimmed.slice("/join ".length).trim()));
-            lastSeenAt = store.recent(channel, 50).at(-1)?.createdAt ?? "";
-            lastActivitySignature = "";
-            rl.setPrompt(`${store.activeWorkspace.slug}${promptName}> `);
-            output.write(`${renderMessages(store.recent(channel, 20))}\n`);
-        }
-        else if (trimmed === "/leave") {
-            if (promptName.startsWith("@")) {
-                output.write("DMs cannot be left in the MVP.\n");
-            }
-            else {
-                const leftChannel = await store.leaveChannel(promptName.slice(1));
-                ({ channelId: channel, promptName } = await selectChannel(store, "general"));
-                lastSeenAt = store.recent(channel, 50).at(-1)?.createdAt ?? "";
-                lastActivitySignature = "";
-                rl.setPrompt(`${store.activeWorkspace.slug}${promptName}> `);
-                output.write(`left #${leftChannel.name}\n${renderMessages(store.recent(channel, 20))}\n`);
-            }
+        historyIndex = undefined;
+        draftInput = "";
+    };
+    const recallInput = (direction) => {
+        if (inputHistory.length === 0) {
+            return;
         }
-        else if (trimmed === "/members") {
-            if (promptName.startsWith("@")) {
-                output.write("DM membership is just the two participants.\n");
-            }
-            else {
-                output.write(`${renderUsers(store.channelMembers(promptName.slice(1)))}\n`);
-            }
+        if (historyIndex === undefined) {
+            draftInput = inputText;
+            historyIndex = direction === -1 ? inputHistory.length - 1 : 0;
         }
-        else if (trimmed.startsWith("/dm ")) {
-            ({ channelId: channel, promptName } = await selectChannel(store, `@${trimmed.slice("/dm ".length).trim()}`));
-            lastSeenAt = store.recent(channel, 50).at(-1)?.createdAt ?? "";
-            lastActivitySignature = "";
-            rl.setPrompt(`${store.activeWorkspace.slug}${promptName}> `);
-            output.write(`${renderMessages(store.recent(channel, 20))}\n`);
+        else {
+            historyIndex += direction;
         }
-        else if (trimmed === "/recent") {
-            output.write(`${renderMessages(store.recent(channel, 20))}\n`);
+        if (historyIndex < 0) {
+            historyIndex = undefined;
+            inputText = draftInput;
+            draftInput = "";
+            return;
         }
-        else if (trimmed.startsWith("/thread ")) {
-            output.write(`${renderMessages(store.thread(trimmed.slice("/thread ".length).trim()))}\n`);
+        if (historyIndex >= inputHistory.length) {
+            historyIndex = undefined;
+            inputText = draftInput;
+            draftInput = "";
+            return;
         }
-        else if (trimmed.startsWith("/reply ")) {
-            const [messageId, ...textParts] = trimmed.slice("/reply ".length).trim().split(/\s+/);
-            if (!messageId || textParts.length === 0) {
-                output.write("Usage: /reply <message-id> <text>\n");
-            }
-            else {
-                const message = await store.reply(messageId, textParts.join(" "));
-                output.write(`sent ${message.id}\n`);
-            }
+        inputText = inputHistory[historyIndex] ?? "";
+    };
+    const runLine = async (line) => {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return;
         }
-        else if (trimmed.startsWith("/react ")) {
-            const [messageId, emoji] = trimmed.slice("/react ".length).trim().split(/\s+/);
-            if (!messageId || !emoji) {
-                output.write("Usage: /react <message-id> <emoji>\n");
-            }
-            else {
-                await store.react(messageId, emoji);
-                output.write(`reacted to ${messageId}\n`);
+        if (trimmed === "/quit" || trimmed === "/exit") {
+            isOpen = false;
+            return;
+        }
+        if (trimmed === "/menu") {
+            showMenu = true;
+            showHelp = false;
+            status = "Command menu";
+            return;
+        }
+        if (trimmed === "/help" || trimmed === "/commands") {
+            showHelp = !showHelp;
+            showMenu = false;
+            status = showHelp ? "Command help" : "";
+            return;
+        }
+        if (trimmed.startsWith("/join ")) {
+            activeChannel = await selectConversation(store, trimmed.slice("/join ".length).trim());
+            await store.markReadConversation(activeChannel.id);
+            status = `Joined ${channelLabel(activeChannel)}`;
+            showHelp = false;
+            showMenu = false;
+            return;
+        }
+        if (trimmed.startsWith("/dm ")) {
+            activeChannel = await selectConversation(store, `@${trimmed.slice("/dm ".length).trim()}`);
+            await store.markReadConversation(activeChannel.id);
+            status = `Opened ${channelLabel(activeChannel)}`;
+            showHelp = false;
+            showMenu = false;
+            return;
+        }
+        if (trimmed.startsWith("/workspace ")) {
+            const workspace = await store.useWorkspace(trimmed.slice("/workspace ".length).trim());
+            activeChannel = await selectConversation(store, "general");
+            status = `Switched to workspace ${workspace.slug}`;
+            showHelp = false;
+            showMenu = false;
+            return;
+        }
+        if (trimmed.startsWith("/")) {
+            status = "Unknown command. Type /help.";
+            return;
+        }
+        const sent = await store.sendMessage(activeChannel.id, trimmed);
+        const messages = store.recent(activeChannel.id, 200);
+        status = messages.some((message) => message.id === sent.id) ? "" : "";
+        showHelp = false;
+        showMenu = false;
+        await store.markReadConversation(activeChannel.id);
+    };
+    const completeInput = () => {
+        const matches = completionCandidates(store, inputText);
+        if (matches.length === 0) {
+            return false;
+        }
+        if (matches.length === 1) {
+            const match = matches[0];
+            if (!match) {
+                return false;
             }
+            inputText = match.value;
+            return true;
         }
-        else if (trimmed.startsWith("/search ")) {
-            output.write(`${renderMessages(store.search(trimmed.slice("/search ".length).trim()))}\n`);
+        const values = matches.map((candidate) => candidate.value);
+        let prefix = values[0] ?? inputText;
+        for (const value of values.slice(1)) {
+            while (!value.startsWith(prefix) && prefix.length > 1) {
+                prefix = prefix.slice(0, -1);
+            }
         }
-        else if (trimmed.startsWith("/")) {
-            output.write(`Unknown command. Type /commands to see commands.\n`);
+        if (prefix.length > inputText.length) {
+            inputText = prefix;
         }
         else {
-            const message = await store.sendMessage(channel, trimmed);
-            lastSeenAt = message.createdAt;
-            output.write(`sent ${message.id}\n`);
+            const firstCommand = commandMatches(inputText)[0];
+            if (firstCommand) {
+                menuIndex = Math.max(0, slashCommands.findIndex((command) => command.name === firstCommand.name));
+                showMenu = true;
+                showHelp = false;
+                status = "Command menu";
+            }
+            else {
+                status = `Matches: ${matches.slice(0, 4).map((candidate) => candidate.label).join("  ")}`;
+            }
         }
-        return "continue";
+        return true;
     };
-    for await (const line of rl) {
-        const trimmed = line.trim();
-        try {
-            if (!trimmed) {
-                rl.prompt();
-                continue;
+    emitKeypressEvents(input);
+    if (input.isTTY) {
+        input.setRawMode?.(true);
+    }
+    input.resume();
+    const onKeypress = (_chunk, key) => {
+        void (async () => {
+            try {
+                if ((key.ctrl && key.name === "c") || key.sequence === "\u0003") {
+                    isOpen = false;
+                    return;
+                }
+                if (showMenu) {
+                    if (key.name === "escape") {
+                        showMenu = false;
+                        status = "";
+                    }
+                    else if (key.name === "up") {
+                        menuIndex = menuIndex === 0 ? slashCommands.length - 1 : menuIndex - 1;
+                    }
+                    else if (key.name === "down" || key.name === "tab") {
+                        menuIndex = menuIndex === slashCommands.length - 1 ? 0 : menuIndex + 1;
+                    }
+                    else if (key.name === "return") {
+                        const selected = slashCommands[menuIndex];
+                        if (!selected) {
+                            showMenu = false;
+                            status = "";
+                            await refresh();
+                            return;
+                        }
+                        showMenu = false;
+                        if (selected.needsArgument) {
+                            inputText = commandInput(selected);
+                            status = `${selected.usage} ${DIM}${selected.description}${RESET}`;
+                        }
+                        else {
+                            inputText = "";
+                            await runLine(selected.name);
+                        }
+                    }
+                    if (!isOpen) {
+                        return;
+                    }
+                    await refresh();
+                    return;
+                }
+                if (key.name === "return") {
+                    const submitted = inputText;
+                    inputText = "";
+                    rememberInput(submitted);
+                    await runLine(submitted);
+                }
+                else if (key.name === "backspace") {
+                    inputText = inputText.slice(0, -1);
+                    historyIndex = undefined;
+                }
+                else if (key.name === "up") {
+                    if (key.ctrl || key.meta || key.sequence === "\u001b[1;5A" || key.sequence === "\u001b[1;3A") {
+                        await switchConversation(-1);
+                        return;
+                    }
+                    recallInput(-1);
+                }
+                else if (key.name === "down") {
+                    if (key.ctrl || key.meta || key.sequence === "\u001b[1;5B" || key.sequence === "\u001b[1;3B") {
+                        await switchConversation(1);
+                        return;
+                    }
+                    recallInput(1);
+                }
+                else if (key.name === "tab") {
+                    if (completeInput()) {
+                        await refresh();
+                        return;
+                    }
+                }
+                else if (key.name === "escape") {
+                    showHelp = false;
+                    showMenu = false;
+                    status = "";
+                }
+                else if (key.sequence && key.sequence >= " " && !key.ctrl) {
+                    inputText += key.sequence;
+                    historyIndex = undefined;
+                }
+                if (!isOpen) {
+                    return;
+                }
+                await refresh();
             }
-            const result = await runSlashLine(trimmed);
-            if (result === "quit") {
-                break;
+            catch (error) {
+                status = error.message;
+                await refresh();
             }
+        })();
+    };
+    input.on("keypress", onKeypress);
+    const poll = setInterval(() => {
+        if (isOpen) {
+            void refresh();
+        }
+    }, 1_500);
+    try {
+        await store.markReadConversation(activeChannel.id);
+        await refresh();
+        while (isOpen) {
+            await new Promise((resolve) => setTimeout(resolve, 50));
         }
-        catch (error) {
-            output.write(`${error.message}\n`);
+    }
+    finally {
+        clearInterval(poll);
+        input.off("keypress", onKeypress);
+        if (input.isTTY) {
+            input.setRawMode?.(false);
         }
-        rl.prompt();
+        output.write(`${SHOW_CURSOR}${RESET}\x1b[2J\x1b[H`);
     }
-    isOpen = false;
-    clearInterval(poll);
-    rl.close();
 }
 //# sourceMappingURL=chat.js.map