dexterm-cli 0.1.6 → 0.1.7

package/dist/packages/cli/src/telegram-cmd.js

@@ -0,0 +1,451 @@
+// `dexterm telegram …` (task-1527, AUTOTRADE-SPEC §8.3): your OWN Telegram bot for the autotrade runner.
+//
+//   setup      read the bot token with a hidden prompt (or from a pipe), check it with getMe (prints the bot's
+//              username only), store it in the OS secret store (macOS keychain, Linux libsecret) or a 0600 file
+//              under ~/.dexterm/secrets/, then pair. The token never goes in a config file, a log, argv or env.
+//   pair       a 6-digit code on THIS screen, valid 5 minutes; send `/pair <code>` to the bot from your own account
+//              in a private chat. Refused while a webhook or a 409 conflict shows someone else polling the bot (they
+//              could read the code); the account that sent it (@username + id) is shown here and needs a local y/N.
+//              Only that account in that chat is allowed; the bot answers nobody else.
+//   status     what is set up (never the token), the paired chats, approvals, notify settings, the audit chain.
+//   approvals  on|off (local; chat can only turn them on). notify <event> on|off. set summary-at|quiet|expiry.
+//   test       send one test message to the paired chats (the manual smoke test; nothing in CI talks to Telegram).
+//   audit      [--verify] the chat audit chain (autotrade/chat/<day>.jsonl).
+//   revoke     remove the token from the store and forget every paired chat.
+// The runner starts the bot by itself when it is set up and paired (`dexterm autotrade run … --paper`; --no-telegram
+// keeps it off). Nothing here is hosted: the bot long-polls from this machine.
+import { dextermHome } from '../../custom/src/index.js';
+import { ChatAudit, PairingWindow, TelegramConnector, TIERS_ALL, chooseSecretStore, connectorsPath, defaultTelegram, loadConnectors, looksLikeBotToken, redact, saveConnectors, secretStore, verifyChatAudit, ChatHub, } from '../../autotrade/src/index.js';
+export const TELEGRAM_USAGE = `dexterm telegram: your own Telegram bot for the autotrade runner (paper first). Nothing is hosted.
+
+  dexterm telegram setup [--tiers notify,control,approve] [--no-pair]
+      store your bot token (hidden prompt or a pipe; never an argument), check it, then pair your account
+  dexterm telegram pair [--tiers notify,control,approve]
+      show a one-time code here; send /pair <code> to your bot from your own private chat (5 minutes)
+  dexterm telegram status [--json]
+  dexterm telegram approvals on|off
+      on: every entry waits for your tap (chat can turn this on, never off)
+  dexterm telegram notify candidates digest|each|off · notify entries|closes|halts|spend|daily on|off
+  dexterm telegram set summary-at HH:MM|off · set quiet HH:MM-HH:MM|off · set expiry 60..120
+  dexterm telegram test        send one test message to your paired chat (manual check)
+  dexterm telegram audit [--verify]
+  dexterm telegram revoke      remove the token and forget every paired chat
+
+  Telegram is not end-to-end encrypted: the bot never sends keys, seed phrases, wallet addresses or balances,
+  and it never asks for them. The bot is your OWN bot for alerts and control of PAPER runs: dexterm holds no key and places
+  no live order (live trading happens in the Telegram trading bot of your choice). Experimental; not financial advice.
+`;
+const flag = (argv, name) => { const i = argv.indexOf(name); return i >= 0 ? argv[i + 1] : undefined; };
+function parseTiers(v) {
+    if (!v)
+        return [...TIERS_ALL];
+    const xs = v.split(',').map((s) => s.trim()).filter(Boolean);
+    if (!xs.length || xs.some((x) => !TIERS_ALL.includes(x)))
+        return null;
+    return [...new Set(xs)];
+}
+/** Hidden input on a real terminal (nothing echoed), or the first line of a pipe. Never an argument or env var. */
+export async function readHidden(io, prompt) {
+    const stdin = io.stdin;
+    if (!stdin)
+        return null;
+    if (stdin.isTTY && typeof stdin.setRawMode === 'function') {
+        io.stderr.write(prompt);
+        return new Promise((resolve) => {
+            let buf = '';
+            const done = (v) => { try {
+                stdin.setRawMode(false);
+            }
+            catch { /* ignore */ } stdin.off('data', onData); stdin.pause(); io.stderr.write('\n'); resolve(v); };
+            const onData = (chunk) => {
+                for (const ch of chunk.toString('utf8')) {
+                    if (ch === '\r' || ch === '\n') {
+                        done(buf.trim() || null);
+                        return;
+                    }
+                    if (ch === '\u0003' || ch === '\u001b') {
+                        done(null);
+                        return;
+                    }
+                    if (ch === '\u007f' || ch === '\b') {
+                        buf = buf.slice(0, -1);
+                        continue;
+                    }
+                    if (ch >= ' ')
+                        buf += ch;
+                }
+            };
+            stdin.setRawMode(true);
+            stdin.on('data', onData);
+            stdin.resume();
+        });
+    }
+    return pipeLine(stdin);
+}
+/** A pipe is read once to its end; its later lines answer later questions (`printf '%s\ny\n' "$TOKEN" | … setup`). */
+const pipeRest = new WeakMap();
+async function pipeLine(stdin) {
+    let lines = pipeRest.get(stdin);
+    if (!lines) {
+        lines = new Promise((resolve) => {
+            let buf = '';
+            stdin.setEncoding('utf8');
+            stdin.on('data', (c) => { buf += c; });
+            stdin.on('end', () => resolve(buf.split('\n')));
+            stdin.on('error', () => resolve([]));
+        });
+        pipeRest.set(stdin, lines);
+    }
+    const l = (await lines).shift();
+    return l === undefined ? null : l.trim() || null;
+}
+/** One visible line from this terminal (or the next line of a pipe); null when there is no input. */
+async function readLine(io, prompt) {
+    const stdin = io.stdin;
+    if (!stdin)
+        return null;
+    io.stderr.write(prompt);
+    if (!stdin.isTTY) {
+        const l = await pipeLine(stdin);
+        io.stderr.write('\n');
+        return l;
+    }
+    const { createInterface } = await import('node:readline');
+    const rl = createInterface({ input: stdin, terminal: false });
+    try {
+        return await new Promise((resolve) => { rl.once('line', (l) => resolve(l.trim())); rl.once('close', () => resolve(null)); });
+    }
+    finally {
+        rl.close();
+        stdin.pause();
+    }
+}
+/** The account as Telegram reports it, safe to print: a handle is [A-Za-z0-9_] only; a display name loses controls. */
+export function describeSender(senderId, sender) {
+    const handle = sender?.username && /^[A-Za-z0-9_]{1,32}$/.test(sender.username) ? `@${sender.username}` : '(no @username)';
+    // eslint-disable-next-line no-control-regex
+    const name = (sender?.name ?? '').replace(/[\u0000-\u001F\u007F-\u009F​-‏‪-‮⁦-⁩]/g, '').trim().slice(0, 64);
+    return `${handle} (id ${senderId}${name ? `, name ${JSON.stringify(name)}` : ''})`;
+}
+const CONFLICT_HELP = 'Someone else may hold your bot token (and may have read the code). Revoke it in @BotFather (/revoke), then run `dexterm telegram setup` with the new token.';
+function load(home, io) {
+    const r = loadConnectors(home);
+    if (!r.ok) {
+        io.stderr.write(`dexterm telegram: ${r.error}\n`);
+        return null;
+    }
+    return r.config;
+}
+function storeOf(home, cfg, io, deps) {
+    if (deps.store)
+        return deps.store;
+    return cfg.telegram.secretStore ? secretStore(cfg.telegram.secretStore, home) : chooseSecretStore(home, io.env);
+}
+function connectorFor(deps, token, io) {
+    return deps.connector ? deps.connector(token) : new TelegramConnector({ token, onLog: (l) => io.stderr.write(`telegram: ${l}\n`) });
+}
+async function pairFlow(home, io, deps, tiers) {
+    const cfg = load(home, io);
+    if (!cfg)
+        return 1;
+    const store = storeOf(home, cfg, io, deps);
+    const token = store.get();
+    if (!token) {
+        io.stderr.write('dexterm telegram: no bot token yet: run `dexterm telegram setup`\n');
+        return 1;
+    }
+    const now = deps.now ?? Date.now;
+    const conn = connectorFor(deps, () => token, io);
+    const audit = new ChatAudit(home, { knownToken: () => token });
+    // 1. Nobody else may be reading this bot: a webhook (or an unanswered check) refuses before a code exists.
+    const hook = conn.checkWebhook ? await conn.checkWebhook() : 'clear';
+    if (hook !== 'clear' || conn.health().conflict) {
+        audit.add(now(), 'pairing_refused', { why: hook === 'clear' ? 'conflict' : `webhook-${hook}` });
+        io.stderr.write(hook === 'unknown'
+            ? 'dexterm telegram: could not check the bot with Telegram (getWebhookInfo); nothing was paired. Try again.\n'
+            : `dexterm telegram: NOT pairing: ${conn.health().conflict ?? 'a webhook is set on this bot'}. ${CONFLICT_HELP}\n`);
+        return 1;
+    }
+    const win = new PairingWindow({ now });
+    const hub = new ChatHub({ connector: conn, config: () => cfg.telegram, audit, badge: 'PAPER', now });
+    const ac = new AbortController();
+    let paired = null;
+    hub.openPairing(win, (r, c) => { if (r.ok) {
+        paired = { senderId: r.senderId, chatId: r.chatId, sender: c.sender };
+        ac.abort();
+    }
+    else if (r.why === 'locked' || r.why === 'conflict')
+        ac.abort(); });
+    io.stdout.write(`Pairing code: ${win.code.slice(0, 3)} ${win.code.slice(3)}\n`);
+    io.stdout.write(`Open a PRIVATE chat with ${cfg.telegram.bot ? `@${cfg.telegram.bot.username}` : 'your bot'} from your own account and send:\n  /pair ${win.code}\n`);
+    io.stdout.write('The code is valid for 5 minutes and works once. Waiting… (Ctrl-C to stop)\n');
+    // The pairing window's own timer holds the event loop until it ends (cleared in the finally below), so the wait
+    // cannot be dropped as "nothing pending" when the connector has no open request at that moment (task-1574).
+    const limit = setTimeout(() => ac.abort(), deps.pairTimeoutMs ?? Math.max(0, win.expiresAt - now()));
+    // 2. A 409 (another getUpdates poll) at any point in the window ends it: that poller may have read the code.
+    const watch = setInterval(() => { if (conn.health().conflict)
+        ac.abort(); }, 100);
+    watch.unref?.();
+    const onSig = () => ac.abort();
+    process.once('SIGINT', onSig);
+    try {
+        await conn.start(ac.signal);
+        await hub.idle();
+    }
+    finally {
+        clearTimeout(limit);
+        clearInterval(watch);
+        process.removeListener('SIGINT', onSig);
+    }
+    // Confirm the update offset, so the runner's first poll does not see the /pair message again.
+    try {
+        await conn.confirmOffset?.();
+    }
+    catch { /* best effort */ }
+    const conflict = conn.health().conflict;
+    if (conflict) {
+        audit.add(now(), 'pairing_refused', { why: 'conflict', codeAccepted: paired !== null });
+        io.stderr.write(`dexterm telegram: NOT paired: ${conflict}. ${CONFLICT_HELP}\n`);
+        return 1;
+    }
+    if (!paired) {
+        io.stderr.write('dexterm telegram: not paired (the code expired, was wrong too often, or you stopped). Run `dexterm telegram pair` again.\n');
+        return 1;
+    }
+    const p = paired;
+    // 3. The code is a shared secret that travelled through Telegram: the person at this computer says whose account it is.
+    const who = describeSender(p.senderId, p.sender);
+    io.stdout.write(`The code came from ${who}, in its private chat with the bot.\n`);
+    const question = `Is ${who} YOUR Telegram account? It gets ${tiers.join(', ')}. [y/N] `;
+    const yes = deps.confirm ? await deps.confirm(question) : /^(y|yes)$/i.test((await readLine(io, question)) ?? '');
+    if (!yes) {
+        audit.add(now(), 'pairing_refused', { why: 'not-confirmed-locally', senderId: p.senderId });
+        io.stderr.write(`dexterm telegram: not paired. If that account is not yours, someone else has your bot token. ${CONFLICT_HELP}\n`);
+        return 1;
+    }
+    // A conflict or a webhook that showed up while the question was open counts too.
+    const late = conn.health().conflict ?? (conn.checkWebhook && (await conn.checkWebhook()) !== 'clear' ? (conn.health().conflict ?? 'the bot could not be checked again') : null);
+    if (late) {
+        audit.add(now(), 'pairing_refused', { why: 'conflict-after-confirm' });
+        io.stderr.write(`dexterm telegram: NOT paired: ${late}. ${CONFLICT_HELP}\n`);
+        return 1;
+    }
+    const next = load(home, io) ?? cfg;
+    next.telegram.allow = [...next.telegram.allow.filter((a) => !(a.senderId === p.senderId && a.chatId === p.chatId)), { senderId: p.senderId, chatId: p.chatId, tiers, pairedAt: now() }];
+    next.telegram.enabled = true;
+    saveConnectors(home, next);
+    audit.add(now(), 'paired', { senderId: p.senderId, chatId: p.chatId, tiers });
+    try {
+        const ref = await conn.send({ chatId: p.chatId }, { kind: 'text', badge: 'PAPER', lines: ['Paired with dexterm on your computer. /help lists the commands. I never ask for keys or seed phrases.'] });
+        audit.add(now(), 'out', { template: 'paired', chatId: p.chatId, messageId: ref.messageId });
+    }
+    catch { /* the pairing is saved; the chat note is a courtesy */ }
+    io.stdout.write(`✓ paired: ${who} in its private chat, tiers ${tiers.join(', ')}. The bot answers nobody else.\n`);
+    io.stdout.write('The runner starts the bot by itself: dexterm autotrade run <strategy> --paper. Turn on Telegram two-step verification for your account.\n');
+    return 0;
+}
+export async function telegramCommand(argv, io, deps = {}) {
+    const sub = argv[0];
+    const home = dextermHome(io.env);
+    try {
+        switch (sub) {
+            case undefined:
+            case 'help':
+            case '--help':
+            case '-h':
+                io.stdout.write(TELEGRAM_USAGE);
+                return 0;
+            case 'setup': {
+                const tiers = parseTiers(flag(argv, '--tiers'));
+                if (!tiers) {
+                    io.stderr.write('dexterm telegram: --tiers takes notify,control,approve\n');
+                    return 2;
+                }
+                if (argv.slice(1).some((a) => looksLikeBotToken(a))) {
+                    io.stderr.write('dexterm telegram: never pass the token as an argument (it would land in your shell history); run setup and paste it at the prompt\n');
+                    return 2;
+                }
+                const cfg = load(home, io);
+                if (!cfg)
+                    return 1;
+                io.stdout.write('1. In Telegram, open @BotFather, send /newbot, and copy the token it gives you.\n2. Paste it below (nothing is shown while you type).\n');
+                const token = await (deps.readToken ? deps.readToken() : readHidden(io, 'bot token: '));
+                if (!token) {
+                    io.stderr.write('dexterm telegram: no token given\n');
+                    return 2;
+                }
+                if (!looksLikeBotToken(token)) {
+                    io.stderr.write('dexterm telegram: that does not look like a bot token (digits, a colon, then about 35 letters, digits, - or _)\n');
+                    return 2;
+                }
+                const conn = connectorFor(deps, () => token, io);
+                let me;
+                try {
+                    if (!conn.getMe)
+                        throw new Error('this connector cannot check a token');
+                    me = await conn.getMe();
+                }
+                catch (e) {
+                    io.stderr.write(`dexterm telegram: the token did not work: ${redact(e.message, token)}\n`);
+                    return 1;
+                }
+                const store = deps.store ?? chooseSecretStore(home, io.env);
+                store.set(token);
+                cfg.telegram = { ...cfg.telegram, bot: { id: me.id, username: me.username }, secretStore: store.kind === 'memory' ? 'file' : store.kind, enabled: cfg.telegram.allow.length > 0 };
+                saveConnectors(home, cfg);
+                io.stdout.write(`✓ bot @${me.username} checked; token stored in ${store.kind === 'keychain' ? 'the macOS keychain' : store.kind === 'libsecret' ? 'the system keyring (libsecret)' : store.kind === 'file' ? 'a 0600 file under your dexterm home (secrets/)' : 'memory'}. Config: ${connectorsPath(home)} (no secrets in it).\n`);
+                if (argv.includes('--no-pair')) {
+                    io.stdout.write('Pair later: dexterm telegram pair\n');
+                    return 0;
+                }
+                return pairFlow(home, io, deps, tiers);
+            }
+            case 'pair': {
+                const tiers = parseTiers(flag(argv, '--tiers'));
+                if (!tiers) {
+                    io.stderr.write('dexterm telegram: --tiers takes notify,control,approve\n');
+                    return 2;
+                }
+                return pairFlow(home, io, deps, tiers);
+            }
+            case 'status': {
+                const cfg = load(home, io);
+                if (!cfg)
+                    return 1;
+                const t = cfg.telegram;
+                const store = t.secretStore ? (deps.store ?? secretStore(t.secretStore, home)) : null;
+                const hasToken = store ? store.get() !== null : false;
+                const chain = verifyChatAudit(home);
+                const view = {
+                    enabled: t.enabled, bot: t.bot ? `@${t.bot.username}` : null, tokenStored: hasToken, secretStore: t.secretStore, tiers: t.tiers,
+                    paired: t.allow.map((a) => ({ senderId: a.senderId, chatId: a.chatId, tiers: a.tiers, pairedAt: a.pairedAt ? new Date(a.pairedAt).toISOString() : null })),
+                    approvals: t.approvals, approvalExpirySec: t.approvalExpirySec, repriceTolPct: t.repriceTolPct, notify: t.notify, dailySummaryAt: t.dailySummaryAt, quietHours: t.quietHours,
+                    audit: { days: chain.length, broken: chain.filter((c) => !c.check.ok).map((c) => c.day) },
+                };
+                if (argv.includes('--json')) {
+                    io.stdout.write(`${JSON.stringify(view, null, 2)}\n`);
+                    return 0;
+                }
+                io.stdout.write(`telegram · ${t.enabled && t.allow.length && hasToken ? 'ready (the runner starts it)' : 'not ready'}\n`);
+                io.stdout.write(`  bot ${view.bot ?? '(not set up)'} · token ${hasToken ? `stored (${t.secretStore})` : 'missing'}\n`);
+                io.stdout.write(`  paired ${t.allow.length ? t.allow.map((a) => `id ${a.senderId} [${a.tiers.join(',')}]`).join('; ') : 'nobody (dexterm telegram pair)'}\n`);
+                io.stdout.write(`  approvals ${t.approvals} · expiry ${t.approvalExpirySec} s · re-quote tolerance ${t.repriceTolPct}%\n`);
+                io.stdout.write(`  notify candidates ${t.notify.candidates} · entries ${t.notify.entries ? 'on' : 'off'} · closes ${t.notify.closes ? 'on' : 'off'} · halts ${t.notify.halts ? 'on' : 'off'} · spend ${t.notify.spend ? 'on' : 'off'} · daily ${t.notify.daily ? `at ${t.dailySummaryAt ?? 'off'}` : 'off'}${t.quietHours ? ` · quiet ${t.quietHours}` : ''}\n`);
+                io.stdout.write(`  audit ${chain.length} day file${chain.length === 1 ? '' : 's'}${view.audit.broken.length ? ` · BROKEN: ${view.audit.broken.join(', ')}` : ''}\n`);
+                return 0;
+            }
+            case 'approvals': {
+                const v = argv[1];
+                if (v !== 'on' && v !== 'off') {
+                    io.stderr.write('dexterm telegram: approvals on|off\n');
+                    return 2;
+                }
+                const cfg = load(home, io);
+                if (!cfg)
+                    return 1;
+                cfg.telegram.approvals = v;
+                saveConnectors(home, cfg);
+                io.stdout.write(v === 'on' ? 'approvals on: every new entry waits for a tap in your paired chat (no answer = skip)\n' : 'approvals off: entries follow the strategy (`entry.decide: "agent+approve"` still asks every time)\n');
+                return 0;
+            }
+            case 'notify': {
+                const ev = argv[1];
+                const v = argv[2];
+                const cfg = load(home, io);
+                if (!cfg)
+                    return 1;
+                if (ev === 'candidates' && (v === 'digest' || v === 'each' || v === 'off'))
+                    cfg.telegram.notify.candidates = v;
+                else if (['entries', 'closes', 'halts', 'spend', 'daily'].includes(ev ?? '') && (v === 'on' || v === 'off'))
+                    cfg.telegram.notify[ev] = v === 'on';
+                else {
+                    io.stderr.write('dexterm telegram: notify candidates digest|each|off, or notify entries|closes|halts|spend|daily on|off\n');
+                    return 2;
+                }
+                saveConnectors(home, cfg);
+                io.stdout.write(`notify ${ev} ${v}\n`);
+                return 0;
+            }
+            case 'set': {
+                const k = argv[1];
+                const v = argv[2];
+                const cfg = load(home, io);
+                if (!cfg || !v) {
+                    if (cfg)
+                        io.stderr.write('dexterm telegram: set summary-at HH:MM|off · set quiet HH:MM-HH:MM|off · set expiry 60..120\n');
+                    return cfg ? 2 : 1;
+                }
+                if (k === 'summary-at' && (v === 'off' || /^([01]\d|2[0-3]):[0-5]\d$/.test(v)))
+                    cfg.telegram.dailySummaryAt = v === 'off' ? null : v;
+                else if (k === 'quiet' && (v === 'off' || /^([01]\d|2[0-3]):[0-5]\d-([01]\d|2[0-3]):[0-5]\d$/.test(v)))
+                    cfg.telegram.quietHours = v === 'off' ? null : v;
+                else if (k === 'expiry' && Number(v) >= 60 && Number(v) <= 120)
+                    cfg.telegram.approvalExpirySec = Math.round(Number(v));
+                else {
+                    io.stderr.write('dexterm telegram: set summary-at HH:MM|off · set quiet HH:MM-HH:MM|off · set expiry 60..120\n');
+                    return 2;
+                }
+                saveConnectors(home, cfg);
+                io.stdout.write(`set ${k} ${v}\n`);
+                return 0;
+            }
+            case 'test': {
+                const cfg = load(home, io);
+                if (!cfg)
+                    return 1;
+                const store = storeOf(home, cfg, io, deps);
+                const token = store.get();
+                if (!token || !cfg.telegram.allow.length) {
+                    io.stderr.write('dexterm telegram: set up and pair first (dexterm telegram setup)\n');
+                    return 1;
+                }
+                const conn = connectorFor(deps, () => token, io);
+                const audit = new ChatAudit(home, { knownToken: () => token });
+                let bad = 0;
+                for (const chatId of [...new Set(cfg.telegram.allow.map((a) => a.chatId))]) {
+                    try {
+                        const ref = await conn.send({ chatId }, { kind: 'text', badge: 'PAPER', lines: ['TEST · dexterm can reach this chat.', 'Commands: /status /pause /kill /help. Trades are approved only with buttons.'] });
+                        audit.add((deps.now ?? Date.now)(), 'out', { template: 'test', chatId, messageId: ref.messageId });
+                        io.stdout.write(`✓ sent to chat ${chatId}\n`);
+                    }
+                    catch (e) {
+                        bad++;
+                        io.stderr.write(`✗ chat ${chatId}: ${redact(e.message, token)}\n`);
+                    }
+                }
+                return bad ? 1 : 0;
+            }
+            case 'audit': {
+                const chain = verifyChatAudit(home);
+                if (!chain.length) {
+                    io.stdout.write('no chat audit yet (autotrade/chat/ under your dexterm home)\n');
+                    return 0;
+                }
+                const verify = argv.includes('--verify');
+                for (const c of chain)
+                    io.stdout.write(verify ? (c.check.ok ? `✓ ${c.day}  ${c.check.events} events  head ${c.check.head}\n` : `✗ ${c.day}  broken at event ${c.check.at}: ${c.check.error}\n`) : `  ${c.day}  ${c.check.events} events\n`);
+                const broken = chain.filter((c) => !c.check.ok).length;
+                if (verify)
+                    io.stdout.write(broken ? `${broken} broken day file${broken === 1 ? '' : 's'}\n` : 'every chat audit chain verifies\n');
+                return verify && broken ? 1 : 0;
+            }
+            case 'revoke': {
+                const cfg = load(home, io);
+                if (!cfg)
+                    return 1;
+                storeOf(home, cfg, io, deps).remove();
+                cfg.telegram = { ...defaultTelegram(), notify: cfg.telegram.notify, dailySummaryAt: cfg.telegram.dailySummaryAt, quietHours: cfg.telegram.quietHours };
+                saveConnectors(home, cfg);
+                io.stdout.write('✓ token removed and every paired chat forgotten. Also revoke the token in @BotFather (/revoke) if it may have leaked.\n');
+                return 0;
+            }
+            default:
+                io.stderr.write(`dexterm telegram: unknown subcommand ${JSON.stringify(sub)}\n\n${TELEGRAM_USAGE}`);
+                return 2;
+        }
+    }
+    catch (e) {
+        io.stderr.write(`dexterm telegram: ${redact(e.message)}\n`);
+        return 1;
+    }
+}

package/dist/packages/cli/src/trade.js

@@ -104,55 +104,16 @@ function editField(ts, key) {
  */
 export function ticketKey(ts, key, ctx) {
     ts.message = null;
-    if (ts.phase === 'filling' || ts.phase === 'signing')
+    if (ts.phase === 'filling')
         return 'none'; // in-flight: ignore input
-    if (ts.phase === 'planning')
-        return 'none'; // the signer is building; esc is handled by the binding (cancel)
-    if (ts.phase === 'filled' || ts.phase === 'error' || ts.phase === 'refused') {
-        // a receipt is showing: esc closes, any other key starts a fresh ticket for the same mint (same mode)
+    if (ts.phase === 'filled' || ts.phase === 'error') {
+        // a receipt is showing: esc closes, any other key starts a fresh ticket for the same mint
         if (key.name === 'esc')
             return 'close';
         const side = ts.side;
         Object.assign(ts, openTicket({ mint: ts.mint, symbol: ts.symbol, decimals: ts.decimals, side, gateOn: ts.gateOn, slippageBps: slippageBps(ts), mode: ts.mode }));
         return 'changed';
     }
-    // ---- LIVE plan screen (task-1328): the keypress gate for a REAL trade. Y / ⏎ confirms (with the
-    // typed-back size above the threshold, exactly like paper); esc returns to editing; ANY other key
-    // cancels — a stray key can never confirm, and never navigates mid-plan.
-    if (ts.phase === 'plan') {
-        if (key.name === 'esc') {
-            ts.phase = 'editing';
-            ts.typeback = '';
-            return 'drop-plan';
-        }
-        if (ts.typebackRequired && key.name === 'char' && key.ch && DIGIT.test(key.ch)) {
-            if (key.ch === '.' && ts.typeback.includes('.'))
-                return 'none';
-            ts.typeback = (ts.typeback + key.ch).slice(0, 12);
-            return 'none';
-        }
-        if (ts.typebackRequired && key.name === 'backspace') {
-            ts.typeback = ts.typeback.slice(0, -1);
-            return 'none';
-        }
-        const confirmKey = (key.name === 'char' && (key.ch === 'y' || key.ch === 'Y')) || key.name === 'enter';
-        if (confirmKey) {
-            if (ts.typebackRequired) {
-                const want = parseNum(ts.sizeInput);
-                const got = parseNum(ts.typeback);
-                if (!(Number.isFinite(got) && Math.abs(got - want) < 1e-9)) {
-                    ts.message = `type the size (${ts.sizeInput}) to confirm this LIVE ${ts.side}`;
-                    return 'none';
-                }
-            }
-            ts.phase = 'signing';
-            return 'confirm-live';
-        }
-        ts.phase = 'editing';
-        ts.typeback = '';
-        ts.message = 'plan cancelled';
-        return 'drop-plan';
-    }
     if (ts.phase === 'confirm') {
         if (key.name === 'esc') {
             ts.phase = 'editing';
@@ -191,8 +152,6 @@ export function ticketKey(ts, key, ctx) {
     // ---- editing
     if (key.name === 'esc')
         return 'close';
-    if (key.name === 'char' && (key.ch === 'L' || key.ch === 'l') && !key.ctrl && !key.alt)
-        return 'toggle-live';
     if (key.name === 'tab') {
         ts.field = ts.field === 'size' ? 'slippage' : 'size';
         return 'none';
@@ -217,97 +176,13 @@ export function ticketKey(ts, key, ctx) {
         }
         ts.typebackRequired = ts.gateOn && ctx.notionalSol > ctx.typebackThresholdSol;
         ts.typeback = '';
-        if (ts.mode === 'live') {
-            ts.phase = 'planning';
-            return 'plan';
-        }
         ts.phase = 'confirm';
         return 'none';
     }
-    // task-1368: f on a LIVE buy = size the order to the signer's cap (the binding knows the caps + SOL/USD; the
-    // reducer only names the effect). Inert on PAPER (no caps) and on a sell (sized in % of the position).
-    if (key.name === 'char' && (key.ch === 'f' || key.ch === 'F') && !key.ctrl && !key.alt) {
-        return ts.mode === 'live' && ts.side === 'buy' ? 'fit-cap' : 'none';
-    }
     if (editField(ts, key))
         return 'changed';
     return 'none';
 }
-// --------------------------------------------------------------------------- task-1368 preflight + hints (pure)
-/**
- * Fees + token-account rent the signer's simulated SOL-out may add on top of the size of a BUY (a tx fee, a priority
- * fee and one associated-token-account rent of 0.00203928 SOL when the wallet has never held the token). The
- * signer prices the LARGER of the planned SOL leg and the simulated SOL out, so a size that is exactly the cap in
- * USD is refused once rent lands on top; `fitSizeSol` leaves this much room.
- */
-export const CAP_FIT_OVERHEAD_SOL = 0.0025;
-const usd = (n) => `$${n.toFixed(2).replace(/\.00$/, '')}`;
-/**
- * Size vs the signer's caps BEFORE ⏎ (task-1368 item b): the USD value of the size at the signer's own SOL/USD, the
- * per-trade cap and what is left of the daily cap, a red verdict when the size is over, and the size that fits.
- * Pure: the signer still decides at precheck/confirm — this only stops the user from building a plan that will be
- * refused for a reason they could not see.
- */
-export function capPreflight(i) {
-    const sizeSol = Number.isFinite(i.sizeSol) && i.sizeSol > 0 ? i.sizeSol : 0;
-    const price = i.solUsd !== null && Number.isFinite(i.solUsd) && i.solUsd > 0 ? i.solUsd : null;
-    const perTradeUsd = Math.max(0, i.perTradeUsd);
-    const dailyRemainingUsd = Math.max(0, i.dailyUsd - Math.max(0, i.spentTodayUsd));
-    const capUsd = Math.min(perTradeUsd, dailyRemainingUsd);
-    const sizeUsd = price !== null && sizeSol > 0 ? sizeSol * price : null;
-    const over = sizeUsd !== null && sizeUsd > capUsd + 1e-9;
-    const binding = !over ? null : dailyRemainingUsd < perTradeUsd ? 'daily' : 'per-trade';
-    const overhead = Math.max(0, i.overheadSol ?? CAP_FIT_OVERHEAD_SOL);
-    let fitSizeSol = null;
-    if (price !== null && capUsd > 0) {
-        const fit = Math.floor((capUsd / price - overhead) * 1000) / 1000;
-        fitSizeSol = fit > 0 ? fit : null;
-    }
-    const capText = `cap ${usd(perTradeUsd)}/trade · ${usd(dailyRemainingUsd)} left of ${usd(Math.max(0, i.dailyUsd))} today`;
-    let line;
-    if (sizeSol <= 0)
-        line = `${capText} · enter a size`;
-    else if (price === null)
-        line = `${sizeSol} SOL = $? (the signer has no SOL/USD yet; it will refuse an unpriced trade on mainnet) · ${capText}`;
-    else if (over) {
-        const which = binding === 'daily' ? `${usd(dailyRemainingUsd)} left today` : `${usd(perTradeUsd)} cap`;
-        line = `${sizeSol} SOL = ${usd(sizeUsd)} > ${which}: ${fitSizeSol !== null ? `use ≤ ${fitSizeSol} SOL (f fits it; fees + token-account rent counted)` : 'nothing fits — the cap is spent for today'}`;
-    }
-    else
-        line = `${sizeSol} SOL ≈ ${usd(sizeUsd)} at SOL ${usd(price)} · ${capText}`;
-    return { sizeSol, sizeUsd, perTradeUsd, dailyRemainingUsd, capUsd, over, fitSizeSol, binding, line };
-}
-const WSOL = 'So11111111111111111111111111111111111111112';
-/**
- * task-1368 item c: a DEVNET signer + a Jupiter swap = a transaction built on MAINNET state (there is no Jupiter
- * devnet): it can never simulate or fill on devnet, so say so BEFORE ⏎ and name the two ways out. Null for the
- * probe (built for devnet on purpose), for wrapped SOL itself, and on mainnet.
- */
-export function devnetMintWarning(a) {
-    if (a.network !== 'devnet' || a.probe || a.mint === WSOL)
-        return null;
-    const caps = `caps ${usd(a.perTradeUsd ?? 5)}/${usd(a.dailyUsd ?? 20)}`;
-    return `DEVNET cannot fill mainnet tokens: paper trade (L) or restart with --mainnet (real funds, ${caps})`;
-}
-const MAINNET_STATE_ERR = /invalid transaction|blockhash|account.*not found|not found|could not find|address (table|lookup)|AccountNotFound|ProgramAccountNotFound|unknown program|InvalidAccountData/i;
-/**
- * task-1368 item f: a plain-English hint under a failed simulation when the failure pattern is the devnet-vs-mainnet
- * mismatch (a mainnet route simulated on a devnet node: accounts, lookup tables or blockhash not found). Null when
- * the simulation passed, was not run, or failed for another reason (the full error is still shown).
- */
-export function simFailureHint(p, caps) {
-    if (p.kind !== 'swap' || !p.sim.ran || p.sim.ok)
-        return null;
-    const err = p.sim.error ?? '';
-    const mainnetState = MAINNET_STATE_ERR.test(err);
-    if (p.network === 'devnet' && (mainnetState || p.mintOnNetwork === false)) {
-        const mint = p.mintOnNetwork === false ? ' (the mint does not exist on devnet)' : '';
-        return `devnet-vs-mainnet wall${mint}: a Jupiter swap is built on MAINNET state (accounts, lookup tables, blockhash) that a devnet node does not have. Paper trade (L) or restart with --mainnet (real funds, caps ${usd(caps?.perTradeUsd ?? 5)}/${usd(caps?.dailyUsd ?? 20)}).`;
-    }
-    if (mainnetState)
-        return 'the node could not find the route\'s accounts or blockhash: a stale plan or the wrong RPC network — rebuild with ⏎, or check --trade-rpc';
-    return null;
-}
 /** SOL notional of a buy order sized in SOL/%, used to gate the typed-back step without a quote. */
 export function buyNotionalSol(ts, balanceLamports) {
     const n = parseNum(ts.sizeInput);

package/dist/packages/cli/src/version.js

@@ -1,3 +1,3 @@
 // The one place the app's version lives (task-1397). --version, the help banner and `dexterm update` read it;
 // cli.test.ts keeps it equal to packages/cli/package.json (release.yml refuses a tag that differs).
-export const VERSION = '0.1.6';
+export const VERSION = '0.1.7';