dexterm-cli 0.1.6 → 0.1.7

package/dist/packages/autotrade/src/chat/service.js

@@ -0,0 +1,248 @@
+// dexterm autotrade chat — the service a runner host starts (task-1527, AUTOTRADE-SPEC §8.1).
+//
+// One process: the runner (`dexterm autotrade run … --paper`) starts the connector when Telegram is set up and
+// paired, so chat is a remote control for THIS local engine. Pieces:
+//   ChatHub         inbound updates: dedupe, allowlist, rate limits, commands → ControlRouter, taps → broker
+//   ApprovalBroker  proposals and confirm buttons (the runner's ApprovalHook)
+//   NotifyBus       the run ledger as it is written → messages
+//   HostControlPort the router's actions, through the SAME control file the CLI and the Q screen write
+//                   (autotrade/control.json, by: "chat"), the runner's live state, and the strategy store
+// The runner never waits on chat: the bus queues, the broker answers when a tap lands, and a dead connection means
+// no entries that need an approval (UNDELIVERED = skip), never a blocked exit.
+import { riskDelta } from '../../../mcp/src/index.js';
+import { StrategyStore } from "../store.js";
+import { requestControl } from "../safety.js";
+import { badgeOf } from "../execution-port.js";
+import { ApprovalBroker, CallbackStore, callbackDbPath } from "./approvals.js";
+import { ChatAudit } from "./audit.js";
+import { defaultTelegram, loadConnectors, saveConnectors } from "./config.js";
+import { ChatHub } from "./hub.js";
+import { NotifyBus } from "./notify.js";
+/** connectors.json re-read when it changes (a local `dexterm telegram approvals off` lands without a restart). */
+export class ConfigView {
+    cached = null;
+    at = 0;
+    home;
+    now;
+    constructor(home, now = Date.now, initial) { this.home = home; this.now = now; this.cached = initial ?? null; }
+    get = () => {
+        if (!this.cached || this.now() - this.at > 2000) {
+            const r = loadConnectors(this.home);
+            // A config that turns unreadable mid-run keeps the last good one for reads but takes away every tier.
+            this.cached = r.ok ? r.config.telegram : { ...(this.cached ?? defaultTelegram()), tiers: [] };
+            this.at = this.now();
+        }
+        return this.cached;
+    };
+    /** The one chat-side write: approvals off → on. */
+    approvalsOn() {
+        const r = loadConnectors(this.home);
+        if (!r.ok)
+            return false;
+        if (r.config.telegram.approvals !== 'on') {
+            r.config.telegram.approvals = 'on';
+            saveConnectors(this.home, r.config);
+        }
+        this.cached = null;
+        return true;
+    }
+}
+/** The router's actions for an in-process runner. Every write is the control file, as the CLI writes it. */
+export class HostControlPort {
+    d;
+    constructor(d) { this.d = d; }
+    store() { return this.d.store ?? new StrategyStore({ home: this.d.home }); }
+    status() {
+        const st = this.d.state();
+        const runId = this.d.runId();
+        if (!st || !runId)
+            return null;
+        const start = st.book.equityUsd - st.book.realizedTodayUsd;
+        const s = this.d.strategy();
+        const cfg = this.d.config.get();
+        return {
+            runId, state: st.state, haltReason: st.haltReason, strategy: st.strategy, open: st.positions.length, candidates: st.candidates.length,
+            dayPnlPct: start > 0 ? (st.book.realizedTodayUsd / start) * 100 : null, spend: { todayUsd: st.spend.todayUsd, dayCapUsd: st.spend.dayCapUsd }, allowance: st.spend.allowance,
+            approvals: s?.entry.decide === 'agent+approve' ? 'required by the strategy' : cfg.approvals,
+        };
+    }
+    positions() {
+        return (this.d.state()?.positions ?? []).map((p) => ({ mint: p.mint, symbol: p.symbol, profile: p.profile, pnlPct: p.pnlPct, freeBag: !!p.freeBag, next: p.next }));
+    }
+    control(action) {
+        const runId = this.d.runId();
+        if (!runId)
+            return { ok: false, message: 'No runner is running on your computer.' };
+        const w = requestControl(this.d.home, runId, action, 'chat');
+        if (!w.ok)
+            return { ok: false, message: `Refused: ${w.why}.` };
+        return { ok: true, message: w.already ? 'Already requested.' : '' };
+    }
+    pause() {
+        const r = this.control('pause');
+        return r.ok ? { ok: true, message: 'Paused: no new entries. Open positions keep their exits. /resume lifts it.' } : r;
+    }
+    resume() {
+        const st = this.d.state();
+        if (!st)
+            return { ok: false, message: 'No runner is running on your computer.' };
+        // Only a pause lifts from chat. A kill, a stop, the panic switch, a breaker halt or a guard stays local.
+        if (st.state !== 'paused' || st.haltReason !== 'paused') {
+            return { ok: false, message: st.state === 'running' ? 'Not paused.' : `Refused from chat: the runner is ${st.state}${st.haltReason ? ` (${st.haltReason})` : ''}. That clears only on your computer.` };
+        }
+        const r = this.control('resume-entries');
+        return r.ok ? { ok: true, message: 'Resumed: new entries allowed again.' } : r;
+    }
+    kill() {
+        const r = this.control('stop');
+        return r.ok ? { ok: true, message: `${r.message || 'Stopped'}: no new entries, sessions closed, pending orders dropped. Open positions keep their exits; the run ends when nothing is held. Starting again is local.` } : r;
+    }
+    flatten() {
+        const r = this.control('flatten');
+        return r.ok ? { ok: true, message: 'Flatten requested: every position sells at its next tick, then the run ends.' } : r;
+    }
+    strategies() {
+        const cur = this.d.strategy();
+        const st = this.store();
+        const out = [];
+        for (const e of st.list()) {
+            if (!e.ok || !e.hash || !e.version)
+                continue;
+            const g = st.get(e.id);
+            if (!g || !g.ok)
+                continue;
+            const s = g.strategy;
+            let allowed = false;
+            let why = 'no strategy is running';
+            if (cur) {
+                if (s.hash === cur.hash) {
+                    allowed = false;
+                    why = 'running';
+                }
+                else if (s.mode !== cur.mode)
+                    why = 'changes paper/live';
+                else {
+                    const d = riskDelta(cur, s);
+                    const looser = d.reasons.filter((r) => r.dir === 'looser');
+                    allowed = looser.length === 0;
+                    why = allowed ? (d.delta === 'tighter' ? 'tighter' : 'equal') : `looser: ${looser.slice(0, 2).map((r) => r.path).join(', ')}`;
+                }
+            }
+            out.push({ id: e.id, version: s.version, hash: s.hash, preset: e.source === 'preset', current: !!cur && cur.hash === s.hash, allowed, why });
+        }
+        return out;
+    }
+    use(id) {
+        const choice = this.strategies().find((x) => x.id === id);
+        if (!choice || !choice.allowed)
+            return { ok: false, message: `Refused: ${id} is not an equal-or-tighter validated strategy now.` };
+        const g = this.store().get(id);
+        if (!g || !g.ok || g.strategy.hash !== choice.hash)
+            return { ok: false, message: 'Refused: that strategy changed since it was listed.' };
+        const r = this.control('stop');
+        if (!r.ok)
+            return r;
+        this.d.onSwitch(g.strategy);
+        return { ok: true, message: `Switching to ${id}: no new entries now; it starts once the open positions have closed.` };
+    }
+    approvalsOn() {
+        return this.d.config.approvalsOn() ? { ok: true, message: 'Approvals on: every new entry now waits for your tap. Turning them off is local only.' } : { ok: false, message: 'Could not write the setting.' };
+    }
+    sell(mint) {
+        const held = (this.d.state()?.positions ?? []).some((p) => p.mint === mint);
+        if (!held)
+            return { ok: false, message: 'Not held any more.' };
+        const b = this.d.broker();
+        if (!b)
+            return { ok: false, message: 'Not available.' };
+        b.queueExit(mint, 'a chat button');
+        return { ok: true, message: 'Sell queued: it goes at the next tick.' };
+    }
+}
+/** What each confirm button runs once its tap is verified (the same actions as the commands, nothing more). */
+export function wireConfirms(broker, port) {
+    broker.onConfirm('flatten', () => port.flatten().message);
+    broker.onConfirm('use', (r) => port.use(String(r.payload.id)).message);
+    broker.onConfirm('sell', (r) => port.sell(String(r.payload.mint)).message);
+}
+export class TelegramService {
+    hub;
+    broker;
+    bus;
+    audit;
+    config;
+    port;
+    o;
+    now;
+    ac = new AbortController();
+    polling = null;
+    ticker = null;
+    store;
+    constructor(o) {
+        this.o = o;
+        this.now = o.now ?? Date.now;
+        this.config = o.config ?? new ConfigView(o.home, this.now);
+        this.audit = o.audit ?? new ChatAudit(o.home, { knownToken: o.knownToken });
+        this.store = o.store ?? new CallbackStore(callbackDbPath(o.home));
+        const cfg = this.config.get;
+        this.broker = new ApprovalBroker({ connector: o.connector, store: this.store, audit: this.audit, port: o.port, config: cfg, now: this.now, maxOpen: o.maxOpen, timers: o.timers, alert: o.alert });
+        this.port = new HostControlPort({ home: o.home, runId: o.runId, state: o.state, strategy: o.strategy, config: this.config, broker: () => this.broker, onSwitch: o.onSwitch ?? (() => { }) });
+        this.hub = new ChatHub({ connector: o.connector, config: cfg, audit: this.audit, badge: badgeOf(o.port.network), broker: this.broker, port: this.port, now: this.now, alert: o.alert });
+        const delays = o.retryDelaysMs ?? [1000, 4000];
+        this.bus = new NotifyBus({
+            badge: badgeOf(o.port.network), config: cfg, now: this.now, card: o.card, approvalCounts: (since) => this.store.countsSince(since),
+            send: async (msg, x) => {
+                for (let i = 0;; i++) {
+                    const failedBefore = this.audit.events.length;
+                    await this.hub.broadcast(msg, x.template);
+                    const failed = this.audit.events.slice(failedBefore).some((e) => e.kind === 'out_failed');
+                    if (!failed || i >= delays.length)
+                        return;
+                    await new Promise((r) => setTimeout(r, delays[i]));
+                }
+            },
+        });
+        wireConfirms(this.broker, this.port);
+    }
+    /** Expire leftovers, start polling and the notify ticker. Resolves once started (polling runs in the background). */
+    async start() {
+        const n = await this.broker.expireLeftovers();
+        this.audit.add(this.now(), 'connector_start', { transport: this.o.connector.transport, expiredLeftovers: n, network: this.o.port.network });
+        this.polling = this.o.connector.start(this.ac.signal).catch((e) => { this.audit.add(this.now(), 'connector_error', { error: e instanceof Error ? e.message.slice(0, 160) : String(e) }); });
+        if (this.o.timers !== false) {
+            this.ticker = setInterval(() => { void this.tick(); }, 5000);
+            this.ticker.unref?.();
+        }
+    }
+    conflictAlerted = false;
+    async tick() {
+        const h = this.o.connector.health();
+        if (h.conflict && !this.conflictAlerted) {
+            this.conflictAlerted = true;
+            this.audit.add(this.now(), 'connector_conflict', { why: h.conflict });
+            this.o.alert?.(`telegram: ${h.conflict}. Approvals are stopped; local controls keep working. Revoke the token with BotFather (/revoke) and run \`dexterm telegram setup\` again.`);
+            this.broker.cancelAll('connector-conflict');
+        }
+        await this.broker.sweep();
+        await this.bus.tick();
+    }
+    /** The run ledger tap: every event, as it is written. */
+    onLedger = (e) => {
+        this.bus.onEvent(e);
+        if (e.kind === 'fill' && typeof e.proposalId === 'string')
+            this.broker.filled(e.proposalId);
+    };
+    onState = (st) => { this.bus.onState(st); };
+    async stop() {
+        this.broker.cancelAll('connector-stopped');
+        if (this.ticker)
+            clearInterval(this.ticker);
+        await this.bus.flush();
+        await this.hub.idle();
+        this.ac.abort();
+        await this.polling;
+        this.broker.close();
+        this.audit.add(this.now(), 'connector_stop', { transport: this.o.connector.transport });
+        this.store.close();
+    }
+}

package/dist/packages/autotrade/src/chat/telegram.js

@@ -0,0 +1,290 @@
+// dexterm autotrade chat — the Telegram transport (task-1527, AUTOTRADE-SPEC §8.2). The user's OWN bot.
+//
+// Long polling from the user's machine: `getUpdates` (timeout 50 s, allowed_updates message + callback_query,
+// offset = last update_id + 1, a dedupe set on top). There is no webhook and no inbound port, so nothing outside can
+// inject an update: every update comes from this process's own poll, and Telegram stamps `from.id` server-side.
+//
+//   sendMessage           plain text: NO parse_mode, link previews off. A token name cannot inject markup or a link.
+//   sendPhoto             the PnL card (multipart, the PNG bytes from the card renderer).
+//   editMessageText       a resolved proposal is edited to its final line and loses its buttons.
+//   answerCallbackQuery   the toast after a tap.
+//   getWebhookInfo        on start and every 10 minutes: a webhook that is set, or a 409 on getUpdates, means someone
+//                         else holds the token. The connector reports a conflict: approvals stop (the broker refuses
+//                         every callback while it is set), the user is alerted locally, local controls keep working.
+//
+// Rate limits: outbound 1 message/s per chat with a burst of 3 (the notify bus digests above 20/min); a 429's
+// `retry_after` is honoured. The token is read once from the secret store and kept in this closure; every error that
+// leaves this file goes through redactedError(), because the Bot API URL contains the token.
+import { parseCommand } from "./connector.js";
+import { clip, plain } from "./format.js";
+import { redact, redactedError } from "./redact.js";
+import { createHash } from 'node:crypto';
+export const TELEGRAM_API = 'https://api.telegram.org';
+export const POLL_TIMEOUT_SEC = 50;
+export const WEBHOOK_CHECK_MS = 10 * 60_000;
+/** Messages older than this when the poll starts are dropped (taps are checked against their own expiry anyway). */
+export const STALE_COMMAND_MS = 120_000;
+const relayed = (m) => m.forward_origin !== undefined || m.forward_from !== undefined || m.forward_from_chat !== undefined
+    || m.forward_sender_name !== undefined || m.forward_date !== undefined || m.via_bot !== undefined || m.is_automatic_forward === true;
+export class TelegramApiError extends Error {
+    code;
+    retryAfter;
+    constructor(code, description, retryAfter, knownToken) {
+        super(`telegram ${code}: ${redact(description, knownToken).slice(0, 200)}`);
+        this.name = 'TelegramApiError';
+        this.code = code;
+        this.retryAfter = retryAfter;
+    }
+}
+const defaultSleep = (ms, signal) => new Promise((r) => {
+    if (signal?.aborted) {
+        r();
+        return;
+    }
+    const t = setTimeout(r, ms);
+    signal?.addEventListener('abort', () => { clearTimeout(t); r(); }, { once: true });
+});
+const kindOf = (c) => (c.type === 'private' ? 'private' : 'group');
+export class TelegramConnector {
+    transport = 'telegram';
+    o;
+    fetchFn;
+    now;
+    sleep;
+    tokenValue = null;
+    offset = 0;
+    seen = new Set();
+    cmdH = [];
+    actH = [];
+    txtH = [];
+    h = { transport: 'telegram', lastPollAt: 0, conflict: null, rateLimited: 0, errors: 0, lastError: null };
+    /** Per chat send budget (1/s, burst 3). */
+    buckets = new Map();
+    lastWebhookCheck = 0;
+    startedAt = 0;
+    constructor(o) {
+        this.o = o;
+        this.fetchFn = o.fetch ?? ((u, i) => fetch(u, i));
+        this.now = o.now ?? Date.now;
+        this.sleep = o.sleep ?? defaultSleep;
+    }
+    token() {
+        if (this.tokenValue === null)
+            this.tokenValue = this.o.token();
+        if (!this.tokenValue)
+            throw new Error('no bot token: run `dexterm telegram setup`');
+        return this.tokenValue;
+    }
+    log(s) { this.o.onLog?.(redact(s, this.tokenValue)); }
+    /** One Bot API call. Requests are built here only; nothing outside sees the URL. */
+    async call(method, body, signal, timeoutMs = 15_000) {
+        const url = `${this.o.apiBase ?? TELEGRAM_API}/bot${this.token()}/${method}`;
+        const sig = signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs);
+        let res;
+        try {
+            res = await this.fetchFn(url, body instanceof FormData
+                ? { method: 'POST', body, signal: sig }
+                : { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body ?? {}), signal: sig });
+        }
+        catch (e) {
+            throw redactedError(e, this.tokenValue);
+        }
+        let j;
+        try {
+            j = (await res.json());
+        }
+        catch (e) {
+            throw redactedError(new Error(`telegram ${res.status}: not JSON (${e.message})`), this.tokenValue);
+        }
+        if (!j.ok)
+            throw new TelegramApiError(j.error_code ?? res.status, j.description ?? 'error', j.parameters?.retry_after ?? null, this.tokenValue);
+        return j.result;
+    }
+    /** The bot's own account (setup prints the username only). */
+    async getMe() {
+        const me = await this.call('getMe');
+        return { id: String(me.id), username: me.username ?? '' };
+    }
+    /** 'clear' only when Telegram answered and no webhook is set; pairing refuses anything else. */
+    async checkWebhook() {
+        this.lastWebhookCheck = this.now();
+        try {
+            const w = await this.call('getWebhookInfo');
+            if (w.url) {
+                this.setConflict('a webhook is set on this bot: someone else may hold its token');
+                return 'webhook';
+            }
+            return 'clear';
+        }
+        catch (e) {
+            this.noteError(e);
+            return 'unknown';
+        }
+    }
+    setConflict(why) {
+        if (this.h.conflict)
+            return;
+        this.h.conflict = why;
+        this.log(`conflict: ${why}`);
+    }
+    noteError(e) {
+        this.h.errors++;
+        this.h.lastError = redact(e instanceof Error ? e.message : String(e), this.tokenValue).slice(0, 200);
+        this.log(`error: ${this.h.lastError}`);
+    }
+    /** Tell Telegram every update up to the last one seen is handled (one short call, no wait). */
+    async confirmOffset() {
+        if (this.offset > 0)
+            await this.call('getUpdates', { offset: this.offset, timeout: 0, limit: 1, allowed_updates: ['message', 'callback_query'] });
+    }
+    async start(signal) {
+        this.startedAt = this.now();
+        await this.checkWebhook();
+        let backoff = 1000;
+        while (!signal.aborted) {
+            if (this.now() - this.lastWebhookCheck >= WEBHOOK_CHECK_MS)
+                await this.checkWebhook();
+            try {
+                const timeout = this.o.pollTimeoutSec ?? POLL_TIMEOUT_SEC;
+                const ups = await this.call('getUpdates', { offset: this.offset, timeout, allowed_updates: ['message', 'callback_query'] }, signal, (timeout + 15) * 1000);
+                this.h.lastPollAt = this.now();
+                backoff = 1000;
+                for (const u of ups)
+                    this.handle(u);
+            }
+            catch (e) {
+                if (signal.aborted)
+                    break;
+                if (e instanceof TelegramApiError && e.code === 409)
+                    this.setConflict('another getUpdates poll or a webhook holds this bot (409)');
+                if (e instanceof TelegramApiError && e.code === 429) {
+                    this.h.rateLimited++;
+                    await this.sleep(Math.max(1, e.retryAfter ?? 5) * 1000, signal);
+                    continue;
+                }
+                this.noteError(e);
+                await this.sleep(backoff, signal);
+                backoff = Math.min(30_000, backoff * 2);
+            }
+        }
+    }
+    /** One update (exported for the transport tests). Duplicates and updates from bots are dropped. */
+    handle(u) {
+        if (typeof u.update_id !== 'number')
+            return;
+        this.offset = Math.max(this.offset, u.update_id + 1);
+        if (this.seen.has(u.update_id))
+            return;
+        this.seen.add(u.update_id);
+        if (this.seen.size > 2000) {
+            const first = this.seen.values().next().value;
+            if (first !== undefined)
+                this.seen.delete(first);
+        }
+        const updateId = String(u.update_id);
+        if (u.callback_query) {
+            const q = u.callback_query;
+            if (!q.message || q.from.is_bot || typeof q.data !== 'string')
+                return;
+            const a = { transport: this.transport, updateId, actionId: q.id, chatId: String(q.message.chat.id), chatKind: kindOf(q.message.chat), senderId: String(q.from.id), ref: { chatId: String(q.message.chat.id), messageId: String(q.message.message_id) }, data: q.data.slice(0, 64), t: (q.message.date ?? 0) * 1000 };
+            for (const h of this.actH)
+                h(a);
+            return;
+        }
+        const m = u.message;
+        if (!m || !m.from || m.from.is_bot || typeof m.text !== 'string')
+            return;
+        // A command typed while nothing was polling (minutes or days ago) is not acted on when the bot comes back.
+        if (this.startedAt && m.date * 1000 < this.startedAt - STALE_COMMAND_MS) {
+            this.h.staleSkipped = (this.h.staleSkipped ?? 0) + 1;
+            return;
+        }
+        const base = { transport: this.transport, updateId, chatId: String(m.chat.id), chatKind: kindOf(m.chat), senderId: String(m.from.id), t: m.date * 1000 };
+        const p = relayed(m) ? null : parseCommand(m.text);
+        if (p) {
+            const name = [m.from.first_name, m.from.last_name].filter((x) => typeof x === 'string' && x).join(' ');
+            const sender = { ...(typeof m.from.username === 'string' && m.from.username ? { username: m.from.username } : {}), ...(name ? { name } : {}) };
+            for (const h of this.cmdH)
+                h({ ...base, sender, command: p.command, args: p.args });
+            return;
+        }
+        const x = { ...base, length: m.text.length, sha256: createHash('sha256').update(m.text).digest('hex') };
+        for (const h of this.txtH)
+            h(x);
+    }
+    /** 1 message/s per chat with a burst of 3 (a token bucket): wait for a slot. */
+    async slot(chatId) {
+        for (;;) {
+            const now = this.now();
+            const b = this.buckets.get(chatId) ?? { tokens: 3, at: now };
+            b.tokens = Math.min(3, b.tokens + Math.max(0, now - b.at) / 1000);
+            b.at = now;
+            this.buckets.set(chatId, b);
+            if (b.tokens >= 1) {
+                b.tokens -= 1;
+                return;
+            }
+            await this.sleep(Math.ceil((1 - b.tokens) * 1000));
+        }
+    }
+    async withRetry(fn) {
+        for (let i = 0;; i++) {
+            try {
+                return await fn();
+            }
+            catch (e) {
+                if (e instanceof TelegramApiError && e.code === 429 && i < 2) {
+                    this.h.rateLimited++;
+                    await this.sleep(Math.max(1, e.retryAfter ?? 3) * 1000);
+                    continue;
+                }
+                throw e instanceof TelegramApiError ? e : redactedError(e, this.tokenValue);
+            }
+        }
+    }
+    markup(msg) {
+        if (msg.kind !== 'proposal')
+            return undefined;
+        return { inline_keyboard: [msg.buttons.map((b) => ({ text: b.label.slice(0, 32), callback_data: b.data }))] };
+    }
+    async send(to, msg) {
+        await this.slot(to.chatId);
+        if (msg.kind === 'card') {
+            return this.withRetry(async () => {
+                const fd = new FormData();
+                fd.set('chat_id', to.chatId);
+                fd.set('caption', clip(plain(msg.badge, [msg.caption]), 1000));
+                fd.set('photo', new Blob([msg.png], { type: 'image/png' }), 'pnl-card.png');
+                const m = await this.call('sendPhoto', fd, undefined, 30_000);
+                return { chatId: to.chatId, messageId: String(m.message_id) };
+            });
+        }
+        return this.withRetry(async () => {
+            const m = await this.call('sendMessage', {
+                chat_id: to.chatId, text: clip(plain(msg.badge, msg.lines)), link_preview_options: { is_disabled: true },
+                ...(this.markup(msg) ? { reply_markup: this.markup(msg) } : {}),
+            });
+            return { chatId: to.chatId, messageId: String(m.message_id) };
+        });
+    }
+    async edit(ref, msg) {
+        if (msg.kind === 'card')
+            return;
+        await this.withRetry(() => this.call('editMessageText', {
+            chat_id: ref.chatId, message_id: Number(ref.messageId), text: clip(plain(msg.badge, msg.lines)), link_preview_options: { is_disabled: true },
+            reply_markup: this.markup(msg) ?? { inline_keyboard: [] },
+        }));
+    }
+    onCommand(h) { this.cmdH.push(h); }
+    onAction(h) { this.actH.push(h); }
+    onText(h) { this.txtH.push(h); }
+    async ackAction(a, toast) {
+        try {
+            await this.call('answerCallbackQuery', { callback_query_id: a.actionId, text: toast.slice(0, 190) });
+        }
+        catch (e) {
+            this.noteError(e);
+        }
+    }
+    health() { return { ...this.h }; }
+}