verybot 0.1.8

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,34 @@
+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>;
+    onLearn?: (channelType: string, channelId: string, topic?: string, teamId?: string) => Promise<{
+        topic?: string;
+        extracted: number;
+        saved: number;
+        skipped: number;
+        savedFacts: string[];
+    }>;
+    onRemember?: (channelType: string, channelId: string, fact: string, teamId?: string) => Promise<{
+        saved: boolean;
+        fact: string;
+    }>;
+    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,276 @@
+import makeWASocket, { useMultiFileAuthState, DisconnectReason, downloadMediaMessage, generateMessageIDV2, } 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, onLearn, onRemember, listTeams, defaultTeamId, selfOnly = false, resolveTableMode = () => "bullets", } = opts;
+    let sock = null;
+    let stopped = false;
+    let reconnectAttempts = 0;
+    let reconnectTimer = null;
+    const typingIntervals = new Map();
+    const commands = new CommandRouter({ onClear, onLearn, onRemember, 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);
+        }
+    }
+    /**
+     * Send an outbound WhatsApp message with a pre-generated ID so we can
+     * suppress self-echoes even if upsert arrives before sendMessage resolves.
+     */
+    async function sendTrackedMessage(jid, content) {
+        const activeSock = sock;
+        if (!activeSock)
+            return;
+        const messageId = generateMessageIDV2(activeSock.user?.id);
+        trackSentId(messageId);
+        const sent = await activeSock.sendMessage(jid, content, { messageId });
+        trackSentId(sent?.key?.id);
+    }
+    /** 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);
+        const hadActiveTyping = Boolean(interval);
+        if (interval) {
+            clearInterval(interval);
+            typingIntervals.delete(jid);
+        }
+        if (hadActiveTyping) {
+            sock?.sendPresenceUpdate("paused", jid).catch(() => { });
+        }
+    }
+    function clearAllTyping() {
+        for (const jid of typingIntervals.keys())
+            stopTyping(jid);
+    }
+    async function connectSocket() {
+        if (stopped)
+            return;
+        // 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...`);
+                    if (reconnectTimer)
+                        clearTimeout(reconnectTimer);
+                    reconnectTimer = setTimeout(() => {
+                        reconnectTimer = null;
+                        void 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) {
+                            const errMsg = err instanceof Error ? err.message : String(err);
+                            logger.error(`[whatsapp] voice transcription failed: ${errMsg}`);
+                            await sendTrackedMessage(jid, { text: "Sorry, I couldn't process your voice message." });
+                        }
+                        finally {
+                            stopTyping(jid);
+                        }
+                        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) {
+                        await sendTrackedMessage(jid, { text: formatResult(cmdResult) });
+                        continue;
+                    }
+                    logger.info(`[whatsapp] message received`);
+                    startTyping(jid);
+                    try {
+                        await onMessage({
+                            channelType: "whatsapp",
+                            channelId: jid,
+                            userId,
+                            text,
+                            teamId: commands.resolveTeamId(jid),
+                        }, channel);
+                    }
+                    finally {
+                        stopTyping(jid);
+                    }
+                }
+                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;
+            if (reconnectTimer) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
+            await connectSocket();
+        },
+        stop: async () => {
+            stopped = true;
+            if (reconnectTimer) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
+            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) {
+                await sendTrackedMessage(channelId, { text });
+                return;
+            }
+            for (const chunk of chunks) {
+                await sendTrackedMessage(channelId, { text: chunk });
+            }
+        },
+        sendVoice: async (channelId, audioPath) => {
+            stopTyping(channelId);
+            const { readFile } = await import("fs/promises");
+            const audio = await readFile(audioPath);
+            await sendTrackedMessage(channelId, {
+                audio,
+                mimetype: "audio/ogg; codecs=opus",
+                ptt: true,
+            });
+            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/claude-login.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Run `claude setup-token` interactively, then ask the user to paste
+ * the resulting token and save it to config.json.
+ */
+export declare function handleClaudeLogin(): Promise<void>;

package/dist/cli/claude-login.js

@@ -0,0 +1,47 @@
+import { spawnSync } from "node:child_process";
+import { createInterface } from "node:readline";
+import { ConfigStore } from "../config/store.js";
+import { BASE_DIR } from "../paths.js";
+/** Prompt the user for a single line of input. */
+function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/**
+ * Run `claude setup-token` interactively, then ask the user to paste
+ * the resulting token and save it to config.json.
+ */
+export async function handleClaudeLogin() {
+    console.log("Running `claude setup-token`...\n");
+    const result = spawnSync("claude", ["setup-token"], {
+        stdio: "inherit",
+        encoding: "utf-8",
+    });
+    if (result.error) {
+        console.error("Failed to run `claude setup-token`. Is the Claude Code CLI installed?\n" +
+            "Install it with: npm install -g @anthropic-ai/claude-code");
+        process.exitCode = 1;
+        return;
+    }
+    if (result.status !== 0) {
+        console.error(`\nclaude setup-token exited with code ${result.status}`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log("");
+    const token = await prompt("Paste the token (sk-ant-oat01-...): ");
+    if (!token.startsWith("sk-ant-")) {
+        console.error("Invalid token — expected it to start with sk-ant-");
+        process.exitCode = 1;
+        return;
+    }
+    const store = new ConfigStore(BASE_DIR);
+    store.patch({ CLAUDE_CODE_OAUTH_TOKEN: token });
+    console.log("\n✓ Token saved to config.json");
+    console.log("  Restart the gateway to use it.");
+}

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;

package/dist/cli/config.js

@@ -0,0 +1,78 @@
+import { ConfigStore } from "../config/store.js";
+import { seedConfigStore, generateGatewayToken } from "../config.js";
+import { BASE_DIR } from "../paths.js";
+/** Resolve a dot-separated path on a nested object. */
+function getByPath(obj, path) {
+    return path.split(".").reduce((o, k) => (o && typeof o === "object" ? o[k] : undefined), obj);
+}
+/** Build a nested partial object from a dot-separated path and a value. */
+function setByPath(path, value) {
+    const keys = path.split(".");
+    if (keys.length === 1)
+        return { [path]: value };
+    const root = {};
+    let current = root;
+    for (let i = 0; i < keys.length - 1; i++) {
+        current[keys[i]] = {};
+        current = current[keys[i]];
+    }
+    current[keys[keys.length - 1]] = value;
+    return root;
+}
+/** Auto-coerce CLI string values to native types. */
+function coerce(raw) {
+    if (raw === "true")
+        return true;
+    if (raw === "false")
+        return false;
+    if (raw === "null")
+        return null;
+    const num = Number(raw);
+    if (!Number.isNaN(num) && raw.trim() !== "")
+        return num;
+    return raw;
+}
+/**
+ * Handle `config get [KEY]` and `config set KEY VALUE` CLI subcommands.
+ * Operates directly on config.json — no gateway boot needed.
+ */
+export function handleConfigCommand(sub, rest) {
+    const store = new ConfigStore(BASE_DIR);
+    seedConfigStore(store);
+    if (sub === "get") {
+        const key = rest[0];
+        if (!key) {
+            console.log(JSON.stringify(store.getRedacted(), null, 2));
+            return;
+        }
+        const data = store.load();
+        const value = getByPath(data, key);
+        if (value === undefined) {
+            console.error(`Key "${key}" not found in config`);
+            process.exitCode = 1;
+            return;
+        }
+        console.log(typeof value === "string" ? value : JSON.stringify(value, null, 2));
+        return;
+    }
+    if (sub === "set") {
+        const [key, ...valueParts] = rest;
+        if (!key || valueParts.length === 0) {
+            console.error("Usage: config set KEY VALUE");
+            process.exitCode = 1;
+            return;
+        }
+        const value = coerce(valueParts.join(" "));
+        store.patch(setByPath(key, value));
+        console.log(`Set ${key}`);
+        return;
+    }
+    if (sub === "regenerate_gateway_token") {
+        const token = generateGatewayToken();
+        store.patch({ GATEWAY_TOKEN: token });
+        console.log(token);
+        return;
+    }
+    console.error("Usage: config get [KEY] | config set KEY VALUE | config regenerate_gateway_token");
+    process.exitCode = 1;
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,11 @@
+export interface RuntimeCliOptions {
+    gatewayHost?: string;
+    gatewayPort?: number;
+}
+/** Parse runtime flags used when launching the main gateway process. */
+export declare function parseRuntimeCliOptions(argv?: string[]): RuntimeCliOptions;
+/**
+ * Route lightweight CLI subcommands without booting the gateway.
+ * Returns a promise (or null) so the caller can await async commands.
+ */
+export declare function handleCli(): Promise<void> | null;