cli-whatsapp 0.1.1 → 0.1.3

package/dist/cli/commands/shell.js

@@ -0,0 +1,655 @@
+import readline, { createInterface } from 'node:readline';
+import { readdirSync, statSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { chats, contacts, search, history } from "./read.js";
+import { reply, buildMediaContent, sendContent } from "./send.js";
+import { media } from "./media.js";
+import { pickFile, pickFromList } from "./filepicker.js";
+import { recent, pin, unpin, archive, unarchive } from "./manage.js";
+import { status } from "./auth.js";
+import { connect, hasSession } from "../../whatsapp/client.js";
+import { registerPersistence, extractText, isGroupJid } from "../../whatsapp/events.js";
+import { listChats, findChat, getMessages, countMessages, } from "../../db/sqlite.js";
+import { resolveTarget } from "../../utils/jid.js";
+import { loadConfig, saveConfig } from "../../config/index.js";
+import { c, displayName, formatTime, truncate, renderMessages } from "../../utils/format.js";
+import { print, warn, printError } from "../../utils/ui.js";
+import { notify } from "../../utils/notify.js";
+// ---- tab completion --------------------------------------------------------
+const SLASH_ITEMS = [
+    { value: '/open', desc: 'open a chat — then just type to send', args: true },
+    { value: '/close', desc: 'leave the current chat' },
+    { value: '/chats', desc: 'list conversations' },
+    { value: '/recent', desc: 'recently active chats' },
+    { value: '/contacts', desc: 'list contacts' },
+    { value: '/history', desc: 'extended message history', args: true },
+    { value: '/search', desc: 'search messages', args: true },
+    { value: '/send', desc: 'send a message to a chat', args: true },
+    { value: '/sendfile', desc: 'send a file (media)', args: true },
+    { value: '/reply', desc: 'reply to a message by #id', args: true },
+    { value: '/media', desc: 'list cached media' },
+    { value: '/pin', desc: 'pin a chat to the top', args: true },
+    { value: '/unpin', desc: 'unpin a chat', args: true },
+    { value: '/archive', desc: 'archive (hide) a chat', args: true },
+    { value: '/unarchive', desc: 'unarchive a chat', args: true },
+    { value: '/connect', desc: 'go live — receive messages' },
+    { value: '/disconnect', desc: 'drop the live connection' },
+    { value: '/status', desc: 'session & cache status' },
+    { value: '/settings', desc: 'view settings' },
+    { value: '/set', desc: 'change a setting', args: true },
+    { value: '/clear', desc: 'clear the screen' },
+    { value: '/help', desc: 'list commands' },
+    { value: '/quit', desc: 'exit' },
+];
+const SLASH = SLASH_ITEMS.map((it) => it.value);
+const CHAT_CMDS = new Set([
+    '/open', '/send', '/sendfile', '/pin', '/unpin', '/archive', '/unarchive', '/history',
+]);
+let nameCache = [];
+function refreshNames() {
+    nameCache = listChats(1000, true).map(displayName);
+}
+function completer(line) {
+    // `@…` anywhere in the line → complete a filesystem path to attach.
+    const lastTok = line.slice(line.lastIndexOf(' ') + 1);
+    if (lastTok.startsWith('@'))
+        return completeAtPath(lastTok);
+    const parts = line.split(/\s+/);
+    if (parts.length <= 1) {
+        if (!line.startsWith('/'))
+            return [[], line];
+        const hits = SLASH.filter((cmd) => cmd.startsWith(line));
+        return [hits.length ? hits : SLASH, line];
+    }
+    if (CHAT_CMDS.has(parts[0])) {
+        const partial = parts[parts.length - 1].toLowerCase();
+        const hits = nameCache.filter((n) => n.toLowerCase().startsWith(partial)).slice(0, 25);
+        return [hits, parts[parts.length - 1]];
+    }
+    return [[], line];
+}
+/** Expand a leading ~ to the home directory. */
+function expandHome(p) {
+    return p.replace(/^~(?=\/|$)/, homedir());
+}
+/**
+ * Tab-completion for an `@<path>` token: lists matching files/dirs so you can
+ * browse the filesystem to attach a file (directories get a trailing /).
+ */
+function completeAtPath(token) {
+    const raw = token.slice(1); // drop the leading '@'
+    const slash = raw.lastIndexOf('/');
+    const dirPart = slash >= 0 ? raw.slice(0, slash + 1) : ''; // keeps trailing /
+    const basePart = slash >= 0 ? raw.slice(slash + 1) : raw;
+    const fsDir = expandHome(dirPart || '.');
+    let entries;
+    try {
+        entries = readdirSync(fsDir);
+    }
+    catch {
+        return [[token], token];
+    }
+    const showHidden = basePart.startsWith('.');
+    const hits = entries
+        .filter((e) => e.startsWith(basePart) && (showHidden || !e.startsWith('.')))
+        .sort()
+        .slice(0, 100)
+        .map((e) => {
+        let suffix = '';
+        try {
+            if (statSync(join(fsDir, e)).isDirectory())
+                suffix = '/';
+        }
+        catch {
+            /* ignore unstatable entries */
+        }
+        return '@' + dirPart + e + suffix;
+    });
+    return [hits.length ? hits : [token], token];
+}
+/**
+ * Find an `@<path>` attachment in a composed message, if the file exists.
+ * Supports `@"quoted paths with spaces"` as well as bare `@path` tokens.
+ */
+function extractAttachment(line) {
+    const m = line.match(/(?:^|\s)@(?:"([^"]+)"|(\S+))/);
+    if (!m || m.index === undefined)
+        return null;
+    const file = expandHome(m[1] ?? m[2]);
+    if (!existsSync(file) || !statSync(file).isFile())
+        return null;
+    const caption = (line.slice(0, m.index) + line.slice(m.index + m[0].length)).trim();
+    return { file, caption };
+}
+// ---- rendering -------------------------------------------------------------
+function banner() {
+    const linked = hasSession();
+    const dot = linked ? c.green('●') : c.red('○');
+    const state = linked ? c.green('linked') : c.red('not linked');
+    const stats = c.dim(`${listChats(5000).length} chats · ${countMessages()} messages`);
+    const lines = [
+        `${c.green('✆')} ${c.bold(c.green('WhatsApp'))} ${c.bold('CLI')}  ${c.dim('interactive')}`,
+        `${dot} ${state}   ${stats}`,
+        linked
+            ? c.dim('Type /open <chat> then just type to chat. /help for commands.')
+            : c.dim('Run /connect after `wa login` to link this device.'),
+    ];
+    const width = Math.min(64, Math.max(...lines.map((l) => stripAnsi(l).length)) + 2);
+    const bar = (l, r) => c.teal(l + '─'.repeat(width) + r);
+    print(bar('╭', '╮'));
+    for (const l of lines) {
+        const pad = ' '.repeat(Math.max(0, width - 1 - stripAnsi(l).length));
+        print(c.teal('│') + ' ' + l + pad + c.teal('│'));
+    }
+    print(bar('╰', '╯'));
+}
+function stripAnsi(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/\x1b\[[0-9;]*m/g, '');
+}
+function statusDot(s) {
+    return s === 'live' ? c.green('●') : s === 'connecting' ? c.yellow('◐') : c.dim('○');
+}
+function setPrompt(state) {
+    const where = state.active ? c.bold(displayName(state.active)) : c.dim('wa');
+    state.rl.setPrompt(`${statusDot(state.status)} ${where} ${c.dim('›')} `);
+}
+/** Print a line above the input prompt without disturbing what's being typed. */
+function printAbove(state, text) {
+    readline.cursorTo(process.stdout, 0);
+    readline.clearLine(process.stdout, 0);
+    process.stdout.write(text + '\n');
+    state.rl.prompt(true);
+}
+function bubble(who, text, incoming) {
+    const time = c.gray(formatTime(Date.now(), loadConfig().preferences.time24h));
+    const name = incoming ? c.cyan(who) : c.green('me');
+    return `${time} ${name}: ${text}`;
+}
+// ---- connection ------------------------------------------------------------
+function onIncoming(state, msg) {
+    if (msg.key.fromMe)
+        return;
+    const jid = msg.key.remoteJid;
+    if (!jid || jid === 'status@broadcast')
+        return;
+    const text = extractText(msg.message) || c.dim('[media]');
+    const chat = findChat(jid);
+    const who = isGroupJid(jid) && msg.pushName
+        ? `${chat ? displayName(chat) : jid.split('@')[0]}/${msg.pushName}`
+        : chat
+            ? displayName(chat)
+            : msg.pushName ?? jid.split('@')[0];
+    if (state.active && jid === state.active.jid) {
+        printAbove(state, bubble(who, text, true));
+    }
+    else {
+        printAbove(state, c.dim(`🔔 ${who}: ${truncate(stripAnsi(text), 60)}`));
+    }
+    if (loadConfig().preferences.notifications) {
+        notify(who, extractText(msg.message) || 'sent media');
+    }
+}
+async function ensureConnected(state) {
+    if (state.conn && state.status === 'live')
+        return state.conn;
+    if (!hasSession()) {
+        warn('Not linked. Run `wa login` in another terminal first.');
+        return null;
+    }
+    state.status = 'connecting';
+    setPrompt(state);
+    printAbove(state, c.dim('connecting…'));
+    try {
+        const conn = await connect({ requireSession: true });
+        registerPersistence(conn.sock, { onMessage: (m) => onIncoming(state, m) });
+        conn.sock.ev.on('connection.update', (u) => {
+            if (u.connection !== 'close' || state.quitting)
+                return;
+            if (state.manualClose) {
+                // User-initiated (/disconnect) — that handler already reported it.
+                state.manualClose = false;
+                return;
+            }
+            state.status = 'offline';
+            state.conn = null;
+            setPrompt(state);
+            printAbove(state, c.dim('disconnected. Type /connect to reconnect.'));
+        });
+        await conn.ready;
+        state.conn = conn;
+        state.status = 'live';
+        setPrompt(state);
+        printAbove(state, c.green('● live — receiving messages'));
+        return conn;
+    }
+    catch (err) {
+        state.status = 'offline';
+        state.conn = null;
+        setPrompt(state);
+        warn(`Could not connect: ${err.message}`);
+        return null;
+    }
+}
+// ---- sending ---------------------------------------------------------------
+async function sendTo(state, jid, name, content, meta) {
+    const conn = await ensureConnected(state);
+    if (!conn)
+        return;
+    try {
+        await sendContent(conn.sock, jid, content, meta);
+        const echo = meta.type === 'text' ? meta.previewText : `[${meta.type}] ${meta.previewText}`;
+        printAbove(state, bubble(name, echo, false));
+        refreshNames();
+    }
+    catch (err) {
+        warn(`Send failed: ${err.message}`);
+    }
+}
+// ---- chat context ----------------------------------------------------------
+function openChat(state, target) {
+    const chat = findChat(target);
+    if (!chat) {
+        warn(`No chat matching "${target}". Try /chats or /search.`);
+        return;
+    }
+    state.active = chat;
+    setPrompt(state);
+    print(c.dim('─'.repeat(40)));
+    print(c.bold(displayName(chat)) + c.dim(`  ${chat.jid}`));
+    print(renderMessages(getMessages(chat.jid, 15), loadConfig().preferences.time24h));
+    print(c.dim(`─── in this chat: type to send · @ opens a file picker to attach · /close ───`));
+}
+// ---- settings --------------------------------------------------------------
+function showSettings() {
+    const cfg = loadConfig();
+    print(c.bold('Settings'));
+    print(`  openLimit       ${c.cyan(String(cfg.preferences.openLimit))}   ${c.dim('messages shown by /open')}`);
+    print(`  time24h         ${c.cyan(String(cfg.preferences.time24h))}   ${c.dim('24-hour clock')}`);
+    print(`  notifications   ${c.cyan(String(cfg.preferences.notifications))}   ${c.dim('desktop alerts on new messages')}`);
+    print(`  autoConnect     ${c.cyan(String(cfg.preferences.autoConnect))}   ${c.dim('go live automatically on start')}`);
+    print(`  ai.enabled      ${c.cyan(String(cfg.ai.enabled))}   ${c.dim('(AI plugin)')}`);
+    print(c.dim('  Change with: /set <key> <value>   e.g. /set autoConnect false'));
+}
+function setSetting(key, value) {
+    const cfg = loadConfig();
+    switch (key) {
+        case 'openLimit':
+            cfg.preferences.openLimit = Math.max(1, parseInt(value, 10) || cfg.preferences.openLimit);
+            break;
+        case 'time24h':
+            cfg.preferences.time24h = value === 'true' || value === '1';
+            break;
+        case 'notifications':
+            cfg.preferences.notifications = value === 'true' || value === '1';
+            break;
+        case 'autoConnect':
+            cfg.preferences.autoConnect = value === 'true' || value === '1';
+            break;
+        case 'ai.enabled':
+            cfg.ai.enabled = value === 'true' || value === '1';
+            break;
+        default:
+            warn(`Unknown key "${key}". Editable: openLimit, time24h, notifications, autoConnect, ai.enabled`);
+            return;
+    }
+    saveConfig(cfg);
+    print(`${c.green('✓')} set ${key} = ${value}`);
+}
+// ---- help ------------------------------------------------------------------
+const HELP = `${c.bold('Commands')} ${c.dim('(slash optional for the first word)')}
+  ${c.cyan('/open')} <chat>          open a chat — then just type to send
+  ${c.green('@')}                       open a file picker to attach (↑↓ to choose, ⏎ to pick)
+  ${c.cyan('/close')}                 leave the current chat
+  ${c.cyan('/chats')} · ${c.cyan('/recent')} · ${c.cyan('/contacts')}   list chats / recent / contacts
+  ${c.cyan('/history')} [n] · ${c.cyan('/search')} <text>       more history / search
+  ${c.cyan('/send')} <chat> <msg>    send without opening
+  ${c.cyan('/sendfile')} <chat> <path> [caption]   send media
+  ${c.cyan('/reply')} <id> <msg>     reply to a message by #id
+  ${c.cyan('/media')} [type]         list media
+  ${c.cyan('/pin')} · ${c.cyan('/unpin')} · ${c.cyan('/archive')} · ${c.cyan('/unarchive')} <chat>
+  ${c.cyan('/connect')} · ${c.cyan('/disconnect')}     go live (receive) / drop connection
+  ${c.cyan('/status')} · ${c.cyan('/settings')} · ${c.cyan('/set')} <k> <v>   status / settings
+  ${c.cyan('/clear')} · ${c.cyan('/help')} · ${c.cyan('/quit')}`;
+// ---- command dispatch ------------------------------------------------------
+function tokenize(line) {
+    const out = [];
+    const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+    let m;
+    while ((m = re.exec(line)))
+        out.push(m[1] ?? m[2] ?? m[3]);
+    return out;
+}
+async function handle(state, raw) {
+    const line = raw.trim();
+    if (!line)
+        return;
+    // Message composed with a chat open (no leading slash).
+    if (!line.startsWith('/') && state.active) {
+        const jid = state.active.jid;
+        const name = displayName(state.active);
+        // `@<path>` attaches a file (rest of the line becomes the caption).
+        const at = extractAttachment(line);
+        if (at) {
+            try {
+                const built = buildMediaContent(at.file, at.caption || undefined);
+                await sendTo(state, jid, name, built.content, {
+                    previewText: at.caption || `[${built.kind}]`,
+                    type: built.kind,
+                    mediaPath: built.path,
+                });
+            }
+            catch (err) {
+                printError(err);
+            }
+            return;
+        }
+        // Otherwise plain text.
+        await sendTo(state, jid, name, { text: line }, { previewText: line, type: 'text' });
+        return;
+    }
+    const [cmdRaw, ...args] = tokenize(line);
+    const cmd = cmdRaw.replace(/^\//, '').toLowerCase();
+    const need = (v, n) => {
+        if (!v) {
+            warn(`Missing <${n}>.`);
+            return false;
+        }
+        return true;
+    };
+    switch (cmd) {
+        case 'quit':
+        case 'exit':
+        case 'q':
+            state.quitting = true;
+            state.rl.close();
+            return;
+        case 'help':
+        case 'h':
+        case '?':
+            print(HELP);
+            return;
+        case 'clear':
+            process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
+            banner();
+            return;
+        case 'open':
+            if (need(args[0], 'chat'))
+                openChat(state, args.join(' '));
+            return;
+        case 'close':
+        case 'back':
+            state.active = null;
+            setPrompt(state);
+            print(c.dim('left chat.'));
+            return;
+        case 'chats':
+            chats({ limit: args[0] });
+            refreshNames();
+            return;
+        case 'recent':
+            recent({ limit: args[0] });
+            return;
+        case 'contacts':
+            contacts({ limit: args[0] });
+            return;
+        case 'history':
+            if (state.active && (!args[0] || /^\d+$/.test(args[0])))
+                history(state.active.jid, { limit: args[0] });
+            else if (need(args[0], 'chat'))
+                history(args[0], { limit: args[1] });
+            return;
+        case 'search':
+            if (need(args[0], 'text'))
+                search(args.join(' '), {});
+            return;
+        case 'media':
+            media(args[0], {});
+            return;
+        case 'status':
+            status();
+            return;
+        case 'settings':
+        case 'config':
+            showSettings();
+            return;
+        case 'set':
+            if (need(args[0], 'key') && need(args[1], 'value'))
+                setSetting(args[0], args[1]);
+            return;
+        case 'pin':
+            if (need(args[0], 'chat')) {
+                pin(args.join(' '));
+                refreshNames();
+            }
+            return;
+        case 'unpin':
+            if (need(args[0], 'chat'))
+                unpin(args.join(' '));
+            return;
+        case 'archive':
+            if (need(args[0], 'chat'))
+                archive(args.join(' '));
+            return;
+        case 'unarchive':
+            if (need(args[0], 'chat'))
+                unarchive(args.join(' '));
+            return;
+        case 'connect':
+        case 'watch':
+        case 'live':
+            await ensureConnected(state);
+            return;
+        case 'disconnect':
+            if (state.conn) {
+                state.manualClose = true; // suppress the drop-listener's message
+                state.conn.close();
+                state.conn = null;
+                state.status = 'offline';
+                setPrompt(state);
+                print(c.dim('disconnected.'));
+            }
+            else
+                print(c.dim('not connected.'));
+            return;
+        case 'send': {
+            if (!need(args[0], 'chat') || !need(args[1], 'message'))
+                return;
+            const t = resolveTarget(args[0]);
+            if (!t) {
+                warn(`Could not resolve "${args[0]}".`);
+                return;
+            }
+            const text = args.slice(1).join(' ');
+            await sendTo(state, t.jid, t.name, { text }, { previewText: text, type: 'text' });
+            return;
+        }
+        case 'sendfile': {
+            if (!need(args[0], 'chat') || !need(args[1], 'path'))
+                return;
+            const t = resolveTarget(args[0]);
+            if (!t) {
+                warn(`Could not resolve "${args[0]}".`);
+                return;
+            }
+            try {
+                const caption = args.slice(2).join(' ') || undefined;
+                const built = buildMediaContent(args[1], caption);
+                await sendTo(state, t.jid, t.name, built.content, {
+                    previewText: caption || `[${built.kind}]`,
+                    type: built.kind,
+                    mediaPath: built.path,
+                });
+            }
+            catch (err) {
+                printError(err);
+            }
+            return;
+        }
+        case 'reply':
+            if (need(args[0], 'id') && need(args[1], 'message'))
+                await reply(args[0], args.slice(1).join(' '));
+            return;
+        default:
+            warn(`Unknown command "${cmd}". Type /help.`);
+    }
+}
+// ---- entry -----------------------------------------------------------------
+/** wa shell — the interactive client. Also runs when `wa` is given no command. */
+export async function shell() {
+    banner();
+    refreshNames();
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        completer,
+        historySize: 200,
+    });
+    const state = { active: null, conn: null, status: 'offline', rl, quitting: false, manualClose: false };
+    setPrompt(state);
+    rl.prompt();
+    // Go live automatically on start (unless disabled or not linked). Fire-and-
+    // forget so browsing stays instant while the socket connects in the background.
+    if (process.stdin.isTTY && hasSession() && loadConfig().preferences.autoConnect) {
+        void ensureConnected(state);
+    }
+    let busy = false;
+    const queue = [];
+    const pump = async () => {
+        if (busy)
+            return;
+        busy = true;
+        while (queue.length) {
+            const line = queue.shift();
+            try {
+                await handle(state, line);
+            }
+            catch (err) {
+                printError(err);
+            }
+        }
+        busy = false;
+        if (!state.quitting)
+            rl.prompt();
+    };
+    rl.on('line', (line) => {
+        queue.push(line);
+        void pump();
+    });
+    // Overlays open synchronously on the trigger key so they reliably capture the
+    // keys you type next (no race with the line being submitted). `/` at the start
+    // of the line opens the slash-command menu; `@` (with a chat open, at a token
+    // boundary) opens the file picker. readline processes the keypress before our
+    // listener, so rl.line already includes the just-typed character.
+    readline.emitKeypressEvents(process.stdin);
+    let pickerOpen = false;
+    // Commands whose <chat> argument gets the live chat picker. "final" = chat is
+    // the last arg (run on pick); "then" = chat then more input (send/sendfile).
+    const CHAT_FINAL = new Set(['open', 'history', 'pin', 'unpin', 'archive', 'unarchive']);
+    const CHAT_THEN = new Set(['send', 'sendfile']);
+    const clearLine = () => rl.write(null, { ctrl: true, name: 'u' });
+    // Open the chat picker for a command, then insert/run with the chosen chat.
+    const chatPickInto = async (cmd) => {
+        const items = listChats(3000, true).map((ch) => ({
+            value: displayName(ch),
+            desc: truncate((ch.lastMessage ?? '').replace(/\s+/g, ' '), 30),
+        }));
+        const chat = await pickFromList('Select a chat', items, '');
+        clearLine();
+        if (!chat)
+            return; // cancelled → empty line
+        const q = /\s/.test(chat) ? `"${chat}"` : chat; // quote names with spaces
+        if (CHAT_THEN.has(cmd))
+            rl.write(`/${cmd} ${q} `); // wait for message/file
+        else {
+            queue.push(`/${cmd} ${q}`); // run right away
+            void pump();
+        }
+    };
+    process.stdin.on('keypress', (str, _key) => {
+        void _key;
+        if (!process.stdin.isTTY || pickerOpen || busy)
+            return;
+        // `/` menu — only when it's the first character on the line.
+        if (str === '/' && rl.line === '/') {
+            pickerOpen = true;
+            void (async () => {
+                try {
+                    const picked = await pickFromList('Slash Commands', SLASH_ITEMS, '');
+                    clearLine();
+                    if (!picked)
+                        return; // cancelled — leave the line empty
+                    const cmd = picked.slice(1);
+                    if (CHAT_FINAL.has(cmd) || CHAT_THEN.has(cmd)) {
+                        await chatPickInto(cmd); // chain straight into the chat picker
+                        return;
+                    }
+                    const item = SLASH_ITEMS.find((i) => i.value === picked);
+                    if (item && !item.args) {
+                        queue.push(picked); // no args → run now
+                        void pump();
+                    }
+                    else {
+                        rl.write(picked + ' '); // needs (non-chat) args → wait
+                    }
+                }
+                finally {
+                    pickerOpen = false;
+                }
+            })();
+            return;
+        }
+        // Space right after a chat command (typed manually) → open the chat picker.
+        if (str === ' ') {
+            const m = rl.line.match(/^\/(open|history|pin|unpin|archive|unarchive|send|sendfile) $/);
+            if (m) {
+                pickerOpen = true;
+                void (async () => {
+                    try {
+                        await chatPickInto(m[1]);
+                    }
+                    finally {
+                        pickerOpen = false;
+                    }
+                })();
+                return;
+            }
+        }
+        // `@` file picker — only with a chat open and at a fresh token boundary.
+        if (str === '@' && state.active) {
+            const before = rl.line.slice(0, Math.max(0, rl.cursor - 1)).replace(/@$/, '');
+            if (before !== '' && !before.endsWith(' '))
+                return;
+            pickerOpen = true;
+            pickFile(process.cwd())
+                .then((picked) => {
+                if (picked)
+                    rl.write(picked.includes(' ') ? `"${picked}"` : picked);
+                else
+                    rl.prompt(true);
+            })
+                .finally(() => {
+                pickerOpen = false;
+            });
+        }
+    });
+    rl.on('SIGINT', () => {
+        if (rl.line) {
+            // Clear the current input on first Ctrl+C.
+            rl.write(null, { ctrl: true, name: 'u' });
+        }
+        else {
+            state.quitting = true;
+            rl.close();
+        }
+    });
+    await new Promise((resolve) => {
+        rl.on('close', () => {
+            state.quitting = true;
+            state.conn?.close();
+            print('\n' + c.dim('Bye.'));
+            resolve();
+        });
+    });
+}