verybot 0.1.3

package/dist/channels/telegram/channel.js

@@ -0,0 +1,156 @@
+import { Bot, InputFile } from "grammy";
+import { transcribe } from "../../tts/transcribe.js";
+import { logger } from "../../logger.js";
+import { markdownToTelegramHtmlChunks, escapeHtml } from "./markdown.js";
+import { CommandRouter } from "../commands.js";
+const TELEGRAM_TEXT_LIMIT = 4000;
+/** Send chunked HTML to a Telegram chat. Handles markdown→HTML conversion + splitting. */
+async function sendHtmlChunks(bot, chatId, text, resolveTableMode) {
+    const tableMode = resolveTableMode();
+    const chunks = markdownToTelegramHtmlChunks(text, TELEGRAM_TEXT_LIMIT, { tableMode });
+    if (chunks.length === 0 && text) {
+        // Fallback: if conversion produced nothing, send raw text
+        await bot.api.sendMessage(chatId, text);
+        return;
+    }
+    for (const chunk of chunks) {
+        await bot.api.sendMessage(chatId, chunk, { parse_mode: "HTML" });
+    }
+}
+export function createTelegramChannel(opts) {
+    const { token, onMessage, onClear, listTeams, defaultTeamId, resolveTableMode = () => "code" } = opts;
+    const bot = new Bot(token);
+    const typingIntervals = new Map();
+    const commands = new CommandRouter({ onClear, listTeams, defaultTeamId });
+    /** Format a CommandResult using Telegram HTML syntax. */
+    function formatTelegramResult(result) {
+        return result.parts
+            .map((p) => {
+            if (typeof p === "string")
+                return escapeHtml(p);
+            if ("bold" in p)
+                return `<b>${escapeHtml(p.bold)}</b>`;
+            return `<code>${escapeHtml(p.code)}</code>`;
+        })
+            .join("");
+    }
+    function startTyping(chatId) {
+        stopTyping(chatId);
+        const numId = Number(chatId);
+        // Send immediately, then every 4s (Telegram typing expires after ~5s)
+        bot.api.sendChatAction(numId, "typing").catch((err) => logger.error(`typing error: ${err}`));
+        logger.info(`typing started for ${chatId}`);
+        const interval = setInterval(() => {
+            bot.api.sendChatAction(numId, "typing").catch((err) => logger.error(`typing interval error: ${err}`));
+        }, 4000);
+        typingIntervals.set(chatId, interval);
+    }
+    function stopTyping(chatId) {
+        const interval = typingIntervals.get(chatId);
+        if (interval) {
+            clearInterval(interval);
+            typingIntervals.delete(chatId);
+        }
+    }
+    const channel = {
+        name: "telegram",
+        start: async () => {
+            for (const cmd of ["clear", "reset"]) {
+                bot.command(cmd, async (ctx) => {
+                    const chatId = String(ctx.chat.id);
+                    const result = await commands.handleClear("telegram", chatId);
+                    await ctx.reply(formatTelegramResult(result), { parse_mode: "HTML" });
+                });
+            }
+            // --- /team command for multi-team switching ---
+            if (listTeams) {
+                bot.command("team", async (ctx) => {
+                    try {
+                        const chatId = String(ctx.chat.id);
+                        const arg = ctx.match?.trim() ?? "";
+                        const result = await commands.handleTeam("telegram", chatId, arg);
+                        await ctx.reply(formatTelegramResult(result), { parse_mode: "HTML" });
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        logger.error(`[telegram] /team command failed: ${msg}`);
+                        await ctx.reply("Failed to process team command. Please try again.");
+                    }
+                });
+            }
+            bot.on("message:voice", async (ctx) => {
+                const chatId = String(ctx.chat.id);
+                logger.info(`[telegram] voice message received from ${chatId}`);
+                startTyping(chatId);
+                try {
+                    const file = await ctx.getFile();
+                    const url = `https://api.telegram.org/file/bot${token}/${file.file_path}`;
+                    const res = await fetch(url);
+                    if (!res.ok)
+                        throw new Error(`Download failed: ${res.status}`);
+                    const buffer = Buffer.from(await res.arrayBuffer());
+                    const text = await transcribe(buffer, file.file_path ?? "voice.ogg");
+                    logger.info(`[telegram] transcribed voice: "${text.slice(0, 100)}"`);
+                    onMessage({
+                        channelType: "telegram",
+                        channelId: chatId,
+                        userId: String(ctx.from.id),
+                        text,
+                        isVoice: true,
+                        teamId: commands.resolveTeamId(chatId),
+                    }, channel);
+                }
+                catch (err) {
+                    stopTyping(chatId);
+                    const msg = err instanceof Error ? err.message : String(err);
+                    logger.error(`[telegram] voice transcription failed: ${msg}`);
+                    await ctx.reply("Sorry, I couldn't process your voice message.");
+                }
+            });
+            bot.on("message:text", (ctx) => {
+                // Skip bot commands — registered ones are handled by bot.command(),
+                // unregistered ones (e.g. /help) should not be forwarded as text
+                const entities = ctx.message.entities ?? [];
+                if (entities.some((e) => e.type === "bot_command" && e.offset === 0))
+                    return;
+                const chatId = String(ctx.chat.id);
+                logger.info(`[telegram] message received from ${chatId}`);
+                startTyping(chatId);
+                onMessage({
+                    channelType: "telegram",
+                    channelId: chatId,
+                    userId: String(ctx.from.id),
+                    text: ctx.message.text,
+                    teamId: commands.resolveTeamId(chatId),
+                }, channel);
+            });
+            // Register commands with Telegram so they appear in the "/" menu
+            const menuCommands = [
+                { command: "clear", description: "Clear the current session." },
+                { command: "reset", description: "Clear the current session." },
+            ];
+            if (listTeams) {
+                menuCommands.push({ command: "team", description: "List or switch teams." });
+            }
+            bot.start();
+            // setMyCommands after start() so Grammy has initialized the bot
+            bot.api.setMyCommands(menuCommands).then(() => logger.info(`[telegram] registered ${menuCommands.length} commands`), (err) => logger.error(`[telegram] setMyCommands failed: ${err}`));
+        },
+        stop: async () => {
+            for (const chatId of typingIntervals.keys())
+                stopTyping(chatId);
+            await bot.stop();
+        },
+        send: async (channelId, text) => {
+            stopTyping(channelId);
+            await sendHtmlChunks(bot, Number(channelId), text, resolveTableMode);
+        },
+        sendVoice: async (channelId, audioPath) => {
+            stopTyping(channelId);
+            const chatId = Number(channelId);
+            await bot.api.sendVoice(chatId, new InputFile(audioPath));
+            logger.info(`[telegram] voice message sent to ${channelId}`);
+        },
+    };
+    return channel;
+}

package/dist/channels/telegram/markdown.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Markdown → Telegram HTML conversion.
+ * Markdown to Telegram HTML conversion.
+ */
+import { type MarkdownTableMode } from "../../markdown/ir.js";
+export declare function escapeHtml(text: string): string;
+export declare function markdownToTelegramHtml(markdown: string, options?: {
+    tableMode?: MarkdownTableMode;
+}): string;
+/**
+ * Convert markdown to chunked Telegram HTML strings.
+ * Each chunk is ≤ `limit` characters of the plain-text IR (the HTML tags
+ * add overhead but Telegram counts the visible text).
+ */
+export declare function markdownToTelegramHtmlChunks(markdown: string, limit: number, options?: {
+    tableMode?: MarkdownTableMode;
+}): string[];

package/dist/channels/telegram/markdown.js

@@ -0,0 +1,66 @@
+/**
+ * Markdown → Telegram HTML conversion.
+ * Markdown to Telegram HTML conversion.
+ */
+import { chunkMarkdownIR, markdownToIR, } from "../../markdown/ir.js";
+import { renderMarkdownWithMarkers } from "../../markdown/render.js";
+export function escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeHtmlAttr(text) {
+    return escapeHtml(text).replace(/"/g, "&quot;");
+}
+const SAFE_LINK_PROTOCOL = /^https?:\/\/|^mailto:|^tel:/i;
+function buildTelegramLink(link, _text) {
+    const href = link.href.trim();
+    if (!href || link.start === link.end) {
+        return null;
+    }
+    if (!SAFE_LINK_PROTOCOL.test(href)) {
+        return null;
+    }
+    const safeHref = escapeHtmlAttr(href);
+    return {
+        start: link.start,
+        end: link.end,
+        open: `<a href="${safeHref}">`,
+        close: "</a>",
+    };
+}
+function renderTelegramHtml(ir) {
+    return renderMarkdownWithMarkers(ir, {
+        styleMarkers: {
+            bold: { open: "<b>", close: "</b>" },
+            italic: { open: "<i>", close: "</i>" },
+            strikethrough: { open: "<s>", close: "</s>" },
+            code: { open: "<code>", close: "</code>" },
+            code_block: { open: "<pre><code>", close: "</code></pre>" },
+        },
+        escapeText: escapeHtml,
+        buildLink: buildTelegramLink,
+    });
+}
+export function markdownToTelegramHtml(markdown, options = {}) {
+    const ir = markdownToIR(markdown ?? "", {
+        linkify: true,
+        headingStyle: "none",
+        blockquotePrefix: "",
+        tableMode: options.tableMode,
+    });
+    return renderTelegramHtml(ir);
+}
+/**
+ * Convert markdown to chunked Telegram HTML strings.
+ * Each chunk is ≤ `limit` characters of the plain-text IR (the HTML tags
+ * add overhead but Telegram counts the visible text).
+ */
+export function markdownToTelegramHtmlChunks(markdown, limit, options = {}) {
+    const ir = markdownToIR(markdown ?? "", {
+        linkify: true,
+        headingStyle: "none",
+        blockquotePrefix: "",
+        tableMode: options.tableMode,
+    });
+    const chunks = chunkMarkdownIR(ir, limit);
+    return chunks.map((chunk) => renderTelegramHtml(chunk));
+}

package/dist/channels/types.d.ts

@@ -0,0 +1,26 @@
+export interface IncomingMessage {
+    channelType: string;
+    channelId: string;
+    userId: string;
+    text?: string;
+    /** Whether this message originated from a voice input. */
+    isVoice?: boolean;
+    /** Team ID resolved by the channel (e.g. via /team command in Telegram). */
+    teamId?: string;
+}
+export type MessageHandler = (msg: IncomingMessage, channel: Channel) => Promise<void>;
+export interface ChannelMessage {
+    user: string;
+    text: string;
+    ts: string;
+}
+export interface Channel {
+    name: string;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(channelId: string, text: string): Promise<void>;
+    /** Send a voice message. Falls back to text if not supported by the channel. */
+    sendVoice?(channelId: string, audioPath: string): Promise<void>;
+    /** Read recent messages from a channel/thread. */
+    readHistory?(channelId: string, limit?: number, threadTs?: string): Promise<ChannelMessage[]>;
+}

package/dist/channels/types.js

@@ -0,0 +1 @@
+export {};

package/dist/channels/whatsapp/channel.d.ts

@@ -0,0 +1,23 @@
+import type { Channel, MessageHandler } from "../types.js";
+import type { MarkdownTableMode } from "../../markdown/ir.js";
+/** Callback that resolves the current table mode from config at send time. */
+export type ResolveTableMode = () => MarkdownTableMode;
+export interface CreateWhatsAppChannelOpts {
+    /**
+     * Opaque identifier for config gating and channel fingerprinting.
+     * Baileys authenticates via QR code; this value is not sent to WhatsApp.
+     * Set any non-empty string (e.g. your phone number) to enable the channel.
+     */
+    phoneId: string;
+    /** When true, only process messages sent by myself (fromMe). */
+    selfOnly?: boolean;
+    onMessage: MessageHandler;
+    onClear?: (channelType: string, channelId: string, teamId?: string) => Promise<void>;
+    listTeams?: () => {
+        id: string;
+        name: string;
+    }[];
+    defaultTeamId?: string;
+    resolveTableMode?: ResolveTableMode;
+}
+export declare function createWhatsAppChannel(opts: CreateWhatsAppChannelOpts): Channel;

package/dist/channels/whatsapp/channel.js

@@ -0,0 +1,242 @@
+import makeWASocket, { useMultiFileAuthState, DisconnectReason, downloadMediaMessage, } from "@whiskeysockets/baileys";
+import { transcribe } from "../../tts/transcribe.js";
+import { logger } from "../../logger.js";
+import { markdownToWhatsAppChunks, escapeWhatsApp, WHATSAPP_TEXT_LIMIT } from "./markdown.js";
+import { CommandRouter } from "../commands.js";
+import { WHATSAPP_AUTH_DIR } from "../../paths.js";
+import { emit } from "../../events.js";
+import QRCode from "qrcode";
+/** Typing indicator refresh interval (WhatsApp presence expires ~10s). */
+const TYPING_INTERVAL_MS = 5000;
+/** Initial reconnect delay (doubles on each attempt). */
+const BASE_RECONNECT_DELAY_MS = 1000;
+/** Cap reconnect backoff at 60s. */
+const MAX_RECONNECT_DELAY_MS = 60_000;
+/** Max number of sent message IDs to track for loop prevention. */
+const SENT_IDS_LIMIT = 500;
+/**
+ * Thin pino-compatible logger adapter that forwards to Winston.
+ * Baileys expects a pino-shaped logger with child(), level, and log methods.
+ */
+function createBaileysLogger() {
+    const noop = () => { };
+    const adapter = {
+        level: "silent",
+        trace: noop,
+        debug: noop,
+        info: (msg) => logger.debug(`[baileys] ${msg}`),
+        warn: (msg) => logger.warn(`[baileys] ${msg}`),
+        error: (msg) => logger.error(`[baileys] ${msg}`),
+        fatal: (msg) => logger.error(`[baileys:fatal] ${msg}`),
+        child: () => adapter,
+    };
+    return adapter;
+}
+export function createWhatsAppChannel(opts) {
+    const { onMessage, onClear, listTeams, defaultTeamId, selfOnly = false, resolveTableMode = () => "bullets", } = opts;
+    let sock = null;
+    let stopped = false;
+    let reconnectAttempts = 0;
+    const typingIntervals = new Map();
+    const commands = new CommandRouter({ onClear, listTeams, defaultTeamId });
+    /** IDs of messages sent by the bot — used to avoid processing our own replies. */
+    const sentIds = new Set();
+    function trackSentId(id) {
+        if (!id)
+            return;
+        sentIds.add(id);
+        if (sentIds.size > SENT_IDS_LIMIT) {
+            const first = sentIds.values().next().value;
+            sentIds.delete(first);
+        }
+    }
+    /** Format a CommandResult using WhatsApp formatting. */
+    function formatResult(result) {
+        return result.parts
+            .map((p) => {
+            if (typeof p === "string")
+                return escapeWhatsApp(p);
+            if ("bold" in p)
+                return `*${escapeWhatsApp(p.bold)}*`;
+            return `\`${p.code}\``;
+        })
+            .join("");
+    }
+    function startTyping(jid) {
+        stopTyping(jid);
+        sock?.sendPresenceUpdate("composing", jid).catch((err) => logger.error(`[whatsapp] typing error: ${err}`));
+        const interval = setInterval(() => {
+            sock?.sendPresenceUpdate("composing", jid).catch((err) => logger.error(`[whatsapp] typing interval error: ${err}`));
+        }, TYPING_INTERVAL_MS);
+        typingIntervals.set(jid, interval);
+    }
+    function stopTyping(jid) {
+        const interval = typingIntervals.get(jid);
+        if (interval) {
+            clearInterval(interval);
+            typingIntervals.delete(jid);
+        }
+        sock?.sendPresenceUpdate("paused", jid).catch(() => { });
+    }
+    function clearAllTyping() {
+        for (const jid of typingIntervals.keys())
+            stopTyping(jid);
+    }
+    async function connectSocket() {
+        // Clear stale typing intervals from previous connection
+        clearAllTyping();
+        const { state, saveCreds } = await useMultiFileAuthState(WHATSAPP_AUTH_DIR);
+        sock = makeWASocket({
+            auth: state,
+            logger: createBaileysLogger(),
+            printQRInTerminal: false, // QR is sent to UI via event bus
+        });
+        sock.ev.on("creds.update", saveCreds);
+        sock.ev.on("connection.update", async (update) => {
+            const { connection, lastDisconnect, qr } = update;
+            // Broadcast QR code to UI clients
+            if (qr) {
+                try {
+                    const dataUrl = await QRCode.toDataURL(qr, { width: 256 });
+                    emit("whatsapp", { type: "qr", dataUrl });
+                }
+                catch (err) {
+                    logger.error(`[whatsapp] QR generation failed: ${err}`);
+                }
+            }
+            if (connection === "close") {
+                emit("whatsapp", { type: "disconnected" });
+                const statusCode = lastDisconnect?.error?.output?.statusCode;
+                const isLoggedOut = statusCode === DisconnectReason.loggedOut;
+                if (isLoggedOut) {
+                    logger.warn("[whatsapp] logged out — will not reconnect");
+                    return;
+                }
+                if (!stopped) {
+                    const delay = Math.min(BASE_RECONNECT_DELAY_MS * 2 ** reconnectAttempts, MAX_RECONNECT_DELAY_MS);
+                    reconnectAttempts++;
+                    logger.info(`[whatsapp] disconnected (code ${statusCode}), reconnecting in ${delay}ms...`);
+                    setTimeout(() => connectSocket(), delay);
+                }
+            }
+            if (connection === "open") {
+                reconnectAttempts = 0;
+                emit("whatsapp", { type: "connected" });
+                logger.info("[whatsapp] connected");
+            }
+        });
+        sock.ev.on("messages.upsert", async ({ messages, type }) => {
+            logger.info(`[whatsapp] messages.upsert: type=${type}, count=${messages.length}`);
+            for (const msg of messages) {
+                try {
+                    logger.info(`[whatsapp] msg: fromMe=${msg.key.fromMe}, jid=${msg.key.remoteJid}, id=${msg.key.id}, hasMessage=${!!msg.message}`);
+                    if (!msg.message)
+                        continue;
+                    // Skip messages sent by the bot to avoid loops
+                    if (msg.key.id && sentIds.has(msg.key.id))
+                        continue;
+                    // In self-only mode, ignore messages from others
+                    if (selfOnly && !msg.key.fromMe)
+                        continue;
+                    const jid = msg.key.remoteJid;
+                    if (!jid)
+                        continue;
+                    const userId = msg.key.participant ?? jid;
+                    // Voice message handling
+                    const audioMsg = msg.message.audioMessage;
+                    if (audioMsg?.ptt) {
+                        logger.info(`[whatsapp] voice message received`);
+                        startTyping(jid);
+                        try {
+                            const buffer = await downloadMediaMessage(msg, "buffer", {});
+                            const text = await transcribe(buffer, "voice.ogg");
+                            logger.info(`[whatsapp] transcribed voice (${text.length} chars)`);
+                            await onMessage({
+                                channelType: "whatsapp",
+                                channelId: jid,
+                                userId,
+                                text,
+                                isVoice: true,
+                                teamId: commands.resolveTeamId(jid),
+                            }, channel);
+                        }
+                        catch (err) {
+                            stopTyping(jid);
+                            const errMsg = err instanceof Error ? err.message : String(err);
+                            logger.error(`[whatsapp] voice transcription failed: ${errMsg}`);
+                            const errReply = await sock?.sendMessage(jid, { text: "Sorry, I couldn't process your voice message." });
+                            trackSentId(errReply?.key?.id);
+                        }
+                        continue;
+                    }
+                    // Text message handling
+                    const text = msg.message.conversation ??
+                        msg.message.extendedTextMessage?.text;
+                    if (!text)
+                        continue;
+                    // Try command handling first
+                    const cmdResult = await commands.handle("whatsapp", jid, text);
+                    if (cmdResult) {
+                        const cmdReply = await sock?.sendMessage(jid, { text: formatResult(cmdResult) });
+                        trackSentId(cmdReply?.key?.id);
+                        continue;
+                    }
+                    logger.info(`[whatsapp] message received`);
+                    startTyping(jid);
+                    await onMessage({
+                        channelType: "whatsapp",
+                        channelId: jid,
+                        userId,
+                        text,
+                        teamId: commands.resolveTeamId(jid),
+                    }, channel);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    logger.error(`[whatsapp] error handling message: ${errMsg}`);
+                }
+            }
+        });
+    }
+    const channel = {
+        name: "whatsapp",
+        start: async () => {
+            stopped = false;
+            reconnectAttempts = 0;
+            await connectSocket();
+        },
+        stop: async () => {
+            stopped = true;
+            clearAllTyping();
+            sock?.end(undefined);
+            sock = null;
+        },
+        send: async (channelId, text) => {
+            stopTyping(channelId);
+            const tableMode = resolveTableMode();
+            const chunks = markdownToWhatsAppChunks(text, WHATSAPP_TEXT_LIMIT, { tableMode });
+            if (chunks.length === 0 && text) {
+                const sent = await sock?.sendMessage(channelId, { text });
+                trackSentId(sent?.key?.id);
+                return;
+            }
+            for (const chunk of chunks) {
+                const sent = await sock?.sendMessage(channelId, { text: chunk });
+                trackSentId(sent?.key?.id);
+            }
+        },
+        sendVoice: async (channelId, audioPath) => {
+            stopTyping(channelId);
+            const { readFile } = await import("fs/promises");
+            const audio = await readFile(audioPath);
+            const sent = await sock?.sendMessage(channelId, {
+                audio,
+                mimetype: "audio/ogg; codecs=opus",
+                ptt: true,
+            });
+            trackSentId(sent?.key?.id);
+            logger.info(`[whatsapp] voice message sent`);
+        },
+    };
+    return channel;
+}

package/dist/channels/whatsapp/markdown.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Markdown → WhatsApp text conversion.
+ * WhatsApp formatting: *bold*, _italic_, ~strikethrough~, `code`, ```code block```
+ * No link syntax — WhatsApp auto-linkifies URLs.
+ */
+import { type MarkdownTableMode } from "../../markdown/ir.js";
+export declare function escapeWhatsApp(text: string): string;
+/** Single-shot conversion (no chunking). */
+export declare function markdownToWhatsApp(markdown: string, options?: {
+    tableMode?: MarkdownTableMode;
+}): string;
+/** WhatsApp message size limit. */
+export declare const WHATSAPP_TEXT_LIMIT = 4096;
+/**
+ * Convert markdown to chunked WhatsApp text strings.
+ * Each chunk is ≤ `limit` characters.
+ */
+export declare function markdownToWhatsAppChunks(markdown: string, limit: number, options?: {
+    tableMode?: MarkdownTableMode;
+}): string[];

package/dist/channels/whatsapp/markdown.js

@@ -0,0 +1,51 @@
+/**
+ * Markdown → WhatsApp text conversion.
+ * WhatsApp formatting: *bold*, _italic_, ~strikethrough~, `code`, ```code block```
+ * No link syntax — WhatsApp auto-linkifies URLs.
+ */
+import { chunkMarkdownIR, markdownToIR, } from "../../markdown/ir.js";
+import { renderMarkdownWithMarkers } from "../../markdown/render.js";
+/** Characters that have formatting meaning in WhatsApp. */
+const WA_SPECIAL = /[*_~`]/g;
+export function escapeWhatsApp(text) {
+    return text.replace(WA_SPECIAL, "\\$&");
+}
+function renderWhatsApp(ir) {
+    return renderMarkdownWithMarkers(ir, {
+        styleMarkers: {
+            bold: { open: "*", close: "*" },
+            italic: { open: "_", close: "_" },
+            strikethrough: { open: "~", close: "~" },
+            code: { open: "`", close: "`" },
+            code_block: { open: "```\n", close: "\n```" },
+        },
+        escapeText: escapeWhatsApp,
+        // No buildLink — WhatsApp auto-linkifies URLs
+    });
+}
+/** Single-shot conversion (no chunking). */
+export function markdownToWhatsApp(markdown, options = {}) {
+    const ir = markdownToIR(markdown ?? "", {
+        linkify: true,
+        headingStyle: "none",
+        blockquotePrefix: "",
+        tableMode: options.tableMode,
+    });
+    return renderWhatsApp(ir);
+}
+/** WhatsApp message size limit. */
+export const WHATSAPP_TEXT_LIMIT = 4096;
+/**
+ * Convert markdown to chunked WhatsApp text strings.
+ * Each chunk is ≤ `limit` characters.
+ */
+export function markdownToWhatsAppChunks(markdown, limit, options = {}) {
+    const ir = markdownToIR(markdown ?? "", {
+        linkify: true,
+        headingStyle: "none",
+        blockquotePrefix: "",
+        tableMode: options.tableMode,
+    });
+    const chunks = chunkMarkdownIR(ir, limit);
+    return chunks.map((chunk) => renderWhatsApp(chunk));
+}

package/dist/cli/config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Handle `config get [KEY]` and `config set KEY VALUE` CLI subcommands.
+ * Operates directly on config.json — no gateway boot needed.
+ */
+export declare function handleConfigCommand(sub: string | undefined, rest: string[]): void;