verybot 0.1.3

package/dist/channels/manager.js

@@ -0,0 +1,100 @@
+import { createHash } from "crypto";
+import { logger } from "../logger.js";
+/** Hash a token to produce a safe fingerprint (never store/log raw secrets). */
+export function channelFingerprint(token) {
+    return createHash("sha256").update(token).digest("hex").slice(0, 16);
+}
+/** Settle delay between stopping an old channel and starting the replacement.
+ *  Telegram's getUpdates long-poll needs ~2s to release server-side. */
+const SETTLE_MS = 2_000;
+export class ChannelManager {
+    channels = [];
+    byName = new Map();
+    fingerprints = new Map();
+    reconciling = false;
+    register(channel, fingerprint) {
+        this.channels.push(channel);
+        this.byName.set(channel.name, channel);
+        if (fingerprint)
+            this.fingerprints.set(channel.name, fingerprint);
+    }
+    /** Look up a channel by name (e.g. "telegram"). */
+    get(name) {
+        return this.byName.get(name);
+    }
+    async startAll() {
+        for (const ch of this.channels) {
+            try {
+                await ch.start();
+                logger.info(`Channel started: ${ch.name}`);
+            }
+            catch (err) {
+                logger.error(`Failed to start channel ${ch.name}: ${err}`);
+            }
+        }
+    }
+    async stopAll() {
+        await Promise.all(this.channels.map((c) => c.stop()));
+    }
+    /** Stop and unregister a single channel by name. */
+    async stopOne(name) {
+        const ch = this.byName.get(name);
+        if (!ch)
+            return false;
+        try {
+            await ch.stop();
+            logger.info(`Channel stopped: ${name}`);
+        }
+        catch (err) {
+            logger.error(`Failed to stop channel ${name}: ${err}`);
+        }
+        this.byName.delete(name);
+        this.fingerprints.delete(name);
+        this.channels = this.channels.filter((c) => c.name !== name);
+        return true;
+    }
+    /**
+     * Diff current channels against desired specs. Stop removed/changed channels,
+     * start new/changed ones. Self-guarding: concurrent calls are skipped
+     * (the next reloadConfig cycle will catch the mismatch).
+     */
+    async reconcile(specs) {
+        if (this.reconciling) {
+            logger.info("Channel reconcile already in progress, skipping");
+            return;
+        }
+        this.reconciling = true;
+        try {
+            const desired = new Map(specs.map((s) => [s.name, s]));
+            // Stop channels that are no longer in config
+            for (const name of [...this.byName.keys()]) {
+                if (!desired.has(name)) {
+                    await this.stopOne(name);
+                }
+            }
+            // Add or replace channels whose fingerprint changed
+            for (const [name, spec] of desired) {
+                if (this.fingerprints.get(name) === spec.fingerprint)
+                    continue;
+                const hadExisting = await this.stopOne(name);
+                // Settle delay so server-side connections release (e.g. Telegram long-poll)
+                if (hadExisting) {
+                    await new Promise((r) => setTimeout(r, SETTLE_MS));
+                }
+                try {
+                    const channel = spec.create();
+                    await channel.start();
+                    this.register(channel, spec.fingerprint);
+                    logger.info(`Channel hot-reloaded: ${name}`);
+                }
+                catch (err) {
+                    // Don't register — next reconcile will retry since no fingerprint is stored
+                    logger.error(`Failed to start channel ${name} during reconcile: ${err}`);
+                }
+            }
+        }
+        finally {
+            this.reconciling = false;
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+import type { Channel, MessageHandler } from "../types.js";
+import type { MarkdownTableMode } from "../../markdown/ir.js";
+export interface SlackSchedulerOpts {
+    /** Register a Slack channel as a connected scheduler channel. */
+    connectScheduler: (teamId: string, channelId: string, sendFn: (text: string) => Promise<void>) => string;
+    /** Unregister a Slack channel from the scheduler. */
+    disconnectScheduler: (teamId: string, key: string) => void;
+}
+/** Callback that resolves the current table mode from config at send time. */
+export type ResolveTableMode = () => MarkdownTableMode;
+export interface CreateSlackChannelOpts {
+    botToken: string;
+    appToken: string;
+    onMessage: MessageHandler;
+    onClear?: (channelType: string, channelId: string, teamId?: string) => Promise<void>;
+    /** List available teams for the /team command. */
+    listTeams?: () => {
+        id: string;
+        name: string;
+    }[];
+    /** Fallback team when no active team is set for a channel. */
+    defaultTeamId?: string;
+    schedulerOpts?: SlackSchedulerOpts;
+    resolveTableMode?: ResolveTableMode;
+}
+export declare function createSlackChannel(opts: CreateSlackChannelOpts): Channel;

package/dist/channels/slack/channel.js

@@ -0,0 +1,207 @@
+import { App } from "@slack/bolt";
+import { logger } from "../../logger.js";
+import { markdownToSlackMrkdwnChunks, escapeSlackMrkdwn, SLACK_TEXT_LIMIT } from "./markdown.js";
+import { CommandRouter } from "../commands.js";
+/** Emoji added while the bot is processing a message. */
+const TYPING_EMOJI = "eyes";
+/** Send chunked Slack mrkdwn to a channel. Optionally in-thread via threadTs. */
+async function sendMrkdwnChunks(app, channelId, text, resolveTableMode, threadTs) {
+    const tableMode = resolveTableMode();
+    const chunks = markdownToSlackMrkdwnChunks(text, SLACK_TEXT_LIMIT, { tableMode });
+    if (chunks.length === 0 && text) {
+        await app.client.chat.postMessage({ channel: channelId, text, thread_ts: threadTs });
+        return;
+    }
+    for (const chunk of chunks) {
+        await app.client.chat.postMessage({ channel: channelId, text: chunk, thread_ts: threadTs });
+    }
+}
+/** Strip the bot mention prefix (e.g. `<@U12345>`) from message text. */
+function stripBotMention(text, botUserId) {
+    const prefix = `<@${botUserId}>`;
+    const trimmed = text.trimStart();
+    if (trimmed.startsWith(prefix)) {
+        return trimmed.slice(prefix.length).trim();
+    }
+    return text.trim();
+}
+export function createSlackChannel(opts) {
+    const { botToken, appToken, onMessage, onClear, listTeams, defaultTeamId, schedulerOpts, resolveTableMode = () => "code", } = opts;
+    const app = new App({
+        token: botToken,
+        appToken,
+        socketMode: true,
+    });
+    const commands = new CommandRouter({ onClear, listTeams, defaultTeamId });
+    /** Map<channelId, { teamId, connectionKey }> for active scheduler connections. */
+    const schedulerConnections = new Map();
+    /**
+     * Track thread context per channelId so replies stay in-thread.
+     * Note: in channels with concurrent @mentions, the latest message wins.
+     * DMs are safe since each DM conversation has a unique channelId.
+     */
+    const threadMap = new Map();
+    /** Format a CommandResult using Slack mrkdwn syntax. */
+    function formatSlackResult(result) {
+        return result.parts
+            .map((p) => {
+            if (typeof p === "string")
+                return escapeSlackMrkdwn(p);
+            if ("bold" in p)
+                return `*${escapeSlackMrkdwn(p.bold)}*`;
+            return `\`${p.code}\``;
+        })
+            .join("");
+    }
+    /**
+     * Handle text-based commands (e.g. "/clear", "/team foo").
+     * Returns true if the message was consumed as a command.
+     */
+    async function handleTextCommand(text, channelId) {
+        const result = await commands.handle("slack", channelId, text);
+        if (!result)
+            return false;
+        await app.client.chat.postMessage({ channel: channelId, text: formatSlackResult(result) });
+        return true;
+    }
+    /** Add a reaction as typing proxy; silently ignore failures. */
+    async function addTypingReaction(channelId, ts) {
+        try {
+            await app.client.reactions.add({ channel: channelId, timestamp: ts, name: TYPING_EMOJI });
+        }
+        catch {
+            // Reaction may already exist or bot lacks permission — safe to ignore
+        }
+    }
+    /** Remove typing reaction; silently ignore failures. */
+    async function removeTypingReaction(channelId, ts) {
+        try {
+            await app.client.reactions.remove({ channel: channelId, timestamp: ts, name: TYPING_EMOJI });
+        }
+        catch {
+            // Safe to ignore
+        }
+    }
+    const channel = {
+        name: "slack",
+        start: async () => {
+            // --- @mention events (channels/groups) ---
+            app.event("app_mention", async ({ event, context }) => {
+                const channelId = event.channel;
+                const userId = event.user ?? "unknown";
+                const botUserId = context.botUserId ?? "";
+                const rawText = event.text ?? "";
+                const text = stripBotMention(rawText, botUserId);
+                const ts = event.ts;
+                const threadTs = event.thread_ts ?? ts;
+                if (!text)
+                    return;
+                if (await handleTextCommand(text, channelId))
+                    return;
+                logger.info(`[slack] mention from ${userId} in ${channelId}`);
+                threadMap.set(channelId, { threadTs, messageTs: ts });
+                await addTypingReaction(channelId, ts);
+                try {
+                    await onMessage({
+                        channelType: "slack",
+                        channelId,
+                        userId,
+                        text,
+                        teamId: commands.resolveTeamId(channelId),
+                    }, channel);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    logger.error(`[slack] error handling mention in ${channelId}: ${msg}`);
+                    await removeTypingReaction(channelId, ts);
+                }
+            });
+            // --- DM events ---
+            app.event("message", async ({ event, context }) => {
+                // Only handle direct messages (im channel type)
+                // Skip bot messages, changed messages, etc.
+                if (!("channel_type" in event) || event.channel_type !== "im")
+                    return;
+                if ("subtype" in event && event.subtype)
+                    return;
+                if (!("user" in event) || !event.user)
+                    return;
+                if (!("text" in event) || !event.text)
+                    return;
+                // Ignore messages from the bot itself
+                if (event.user === context.botUserId)
+                    return;
+                const channelId = event.channel;
+                const userId = event.user;
+                const botUserId = context.botUserId ?? "";
+                // Strip bot mention so "@bot /clear" is matched as "/clear"
+                const text = stripBotMention(event.text, botUserId);
+                const ts = event.ts;
+                const threadTs = ("thread_ts" in event ? event.thread_ts : undefined) ?? ts;
+                if (await handleTextCommand(text, channelId))
+                    return;
+                logger.info(`[slack] DM from ${userId}`);
+                threadMap.set(channelId, { threadTs, messageTs: ts });
+                await addTypingReaction(channelId, ts);
+                try {
+                    await onMessage({
+                        channelType: "slack",
+                        channelId,
+                        userId,
+                        text,
+                        teamId: commands.resolveTeamId(channelId),
+                    }, channel);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    logger.error(`[slack] error handling DM from ${userId}: ${msg}`);
+                    await removeTypingReaction(channelId, ts);
+                }
+            });
+            await app.start();
+            logger.info("[slack] connected via Socket Mode");
+        },
+        stop: async () => {
+            for (const [, conn] of schedulerConnections) {
+                schedulerOpts?.disconnectScheduler(conn.teamId, conn.connectionKey);
+            }
+            schedulerConnections.clear();
+            await app.stop();
+            logger.info("[slack] disconnected");
+        },
+        send: async (channelId, text) => {
+            const entry = threadMap.get(channelId);
+            await sendMrkdwnChunks(app, channelId, text, resolveTableMode, entry?.threadTs);
+            if (entry) {
+                await removeTypingReaction(channelId, entry.messageTs);
+            }
+        },
+        readHistory: async (channelId, limit = 20, threadTs) => {
+            logger.info(`[slack] readHistory channel=${channelId} limit=${limit} threadTs=${threadTs ?? "none"}`);
+            let raw;
+            if (threadTs) {
+                const result = await app.client.conversations.replies({
+                    channel: channelId,
+                    ts: threadTs,
+                    limit,
+                });
+                raw = result.messages ?? [];
+            }
+            else {
+                const result = await app.client.conversations.history({
+                    channel: channelId,
+                    limit,
+                });
+                // conversations.history returns newest-first, reverse for chronological
+                raw = (result.messages ?? []).reverse();
+            }
+            logger.info(`[slack] readHistory returned ${raw.length} messages for ${channelId}`);
+            return raw.map((msg) => ({
+                user: msg.user ?? "bot",
+                text: msg.text ?? "",
+                ts: msg.ts ?? "",
+            }));
+        },
+    };
+    return channel;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Markdown → Slack mrkdwn conversion.
+ * Slack uses a custom markdown-like format called "mrkdwn".
+ */
+import { type MarkdownTableMode } from "../../markdown/ir.js";
+/** Slack mrkdwn uses &, <, > as control chars — escape them in plain text. */
+export declare function escapeSlackMrkdwn(text: string): string;
+export declare function markdownToSlackMrkdwn(markdown: string, options?: {
+    tableMode?: MarkdownTableMode;
+}): string;
+/** Slack message limit (text blocks). */
+export declare const SLACK_TEXT_LIMIT = 4000;
+/**
+ * Convert markdown to chunked Slack mrkdwn strings.
+ * Each chunk is ≤ `limit` characters of plain-text IR.
+ */
+export declare function markdownToSlackMrkdwnChunks(markdown: string, limit?: number, options?: {
+    tableMode?: MarkdownTableMode;
+}): string[];

package/dist/channels/slack/markdown.js

@@ -0,0 +1,62 @@
+/**
+ * Markdown → Slack mrkdwn conversion.
+ * Slack uses a custom markdown-like format called "mrkdwn".
+ */
+import { chunkMarkdownIR, markdownToIR, } from "../../markdown/ir.js";
+import { renderMarkdownWithMarkers } from "../../markdown/render.js";
+const SAFE_LINK_PROTOCOL = /^https?:\/\/|^mailto:|^tel:/i;
+/** Slack mrkdwn uses &, <, > as control chars — escape them in plain text. */
+export function escapeSlackMrkdwn(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function buildSlackLink(link, _text) {
+    const href = link.href.trim();
+    if (!href || link.start === link.end)
+        return null;
+    if (!SAFE_LINK_PROTOCOL.test(href))
+        return null;
+    return {
+        start: link.start,
+        end: link.end,
+        open: `<${escapeSlackMrkdwn(href)}|`,
+        close: ">",
+    };
+}
+function renderSlackMrkdwn(ir) {
+    return renderMarkdownWithMarkers(ir, {
+        styleMarkers: {
+            bold: { open: "*", close: "*" },
+            italic: { open: "_", close: "_" },
+            strikethrough: { open: "~", close: "~" },
+            code: { open: "`", close: "`" },
+            code_block: { open: "```\n", close: "\n```" },
+        },
+        escapeText: escapeSlackMrkdwn,
+        buildLink: buildSlackLink,
+    });
+}
+export function markdownToSlackMrkdwn(markdown, options = {}) {
+    const ir = markdownToIR(markdown ?? "", {
+        linkify: true,
+        headingStyle: "none",
+        blockquotePrefix: "> ",
+        tableMode: options.tableMode,
+    });
+    return renderSlackMrkdwn(ir);
+}
+/** Slack message limit (text blocks). */
+export const SLACK_TEXT_LIMIT = 4000;
+/**
+ * Convert markdown to chunked Slack mrkdwn strings.
+ * Each chunk is ≤ `limit` characters of plain-text IR.
+ */
+export function markdownToSlackMrkdwnChunks(markdown, limit = SLACK_TEXT_LIMIT, options = {}) {
+    const ir = markdownToIR(markdown ?? "", {
+        linkify: true,
+        headingStyle: "none",
+        blockquotePrefix: "> ",
+        tableMode: options.tableMode,
+    });
+    const chunks = chunkMarkdownIR(ir, limit);
+    return chunks.map((chunk) => renderSlackMrkdwn(chunk));
+}

package/dist/channels/specs.d.ts

@@ -0,0 +1,21 @@
+import type { MessageHandler } from "./types.js";
+import type { ChannelSpec } from "./manager.js";
+import type { MarkdownTableMode } from "../markdown/ir.js";
+import type { ConnectedChannelRegistry } from "../scheduler/connected-channels.js";
+import type { Config } from "../config.js";
+export interface ChannelCallbacks {
+    onMessage: MessageHandler;
+    onClear: (channelType: string, channelId: string, teamId?: string) => Promise<void>;
+    listTeams: () => {
+        id: string;
+        name: string;
+    }[];
+    connectedChannels: ConnectedChannelRegistry | null;
+    /** Return the raw per-channel table config value (resolved lazily at send time). */
+    getChannelTableConfig: (channel: string) => MarkdownTableMode | string | null | undefined;
+}
+/**
+ * Build channel specs from config. Pure function — all side effects are
+ * deferred via callbacks so agent.ts stays thin.
+ */
+export declare function buildChannelSpecs(config: Config, cb: ChannelCallbacks): ChannelSpec[];

package/dist/channels/specs.js

@@ -0,0 +1,96 @@
+import { channelFingerprint } from "./manager.js";
+import { createTelegramChannel } from "./telegram/channel.js";
+import { createDiscordChannel } from "./discord/channel.js";
+import { createSlackChannel } from "./slack/channel.js";
+import { createWhatsAppChannel } from "./whatsapp/channel.js";
+import { resolveMarkdownTableMode } from "../markdown/tables.js";
+import { DEFAULT_TEAM_ID } from "../config/agent-config.js";
+/** Build scheduler opts shared across channels. */
+function buildSchedulerOpts(channelType, connectedChannels) {
+    return {
+        connectScheduler: (teamId, channelId, sendFn) => connectedChannels.connect(teamId, {
+            channelType,
+            channelId,
+            send: sendFn,
+        }),
+        disconnectScheduler: (teamId, key) => connectedChannels.disconnect(teamId, key),
+    };
+}
+/**
+ * Build channel specs from config. Pure function — all side effects are
+ * deferred via callbacks so agent.ts stays thin.
+ */
+export function buildChannelSpecs(config, cb) {
+    const specs = [];
+    if (config.channels.telegram) {
+        const token = config.channels.telegram.token;
+        const resolveTableMode = () => resolveMarkdownTableMode({ channel: "telegram", channelTableMode: cb.getChannelTableConfig("telegram") });
+        specs.push({
+            name: "telegram",
+            fingerprint: channelFingerprint(token),
+            create: () => createTelegramChannel({
+                token,
+                defaultTeamId: DEFAULT_TEAM_ID,
+                listTeams: cb.listTeams,
+                onMessage: cb.onMessage,
+                onClear: cb.onClear,
+                resolveTableMode,
+            }),
+        });
+    }
+    if (config.channels.discord) {
+        const token = config.channels.discord.token;
+        const resolveTableMode = () => resolveMarkdownTableMode({ channel: "discord", channelTableMode: cb.getChannelTableConfig("discord") });
+        specs.push({
+            name: "discord",
+            fingerprint: channelFingerprint(token),
+            create: () => createDiscordChannel({
+                token,
+                defaultTeamId: DEFAULT_TEAM_ID,
+                listTeams: cb.listTeams,
+                onMessage: cb.onMessage,
+                onClear: cb.onClear,
+                resolveTableMode,
+            }),
+        });
+    }
+    if (config.channels.slack) {
+        const { botToken, appToken } = config.channels.slack;
+        const resolveTableMode = () => resolveMarkdownTableMode({ channel: "slack", channelTableMode: cb.getChannelTableConfig("slack") });
+        const schedulerOpts = cb.connectedChannels
+            ? buildSchedulerOpts("slack", cb.connectedChannels)
+            : undefined;
+        specs.push({
+            name: "slack",
+            fingerprint: channelFingerprint(botToken + appToken),
+            create: () => createSlackChannel({
+                botToken,
+                appToken,
+                defaultTeamId: DEFAULT_TEAM_ID,
+                listTeams: cb.listTeams,
+                onMessage: cb.onMessage,
+                onClear: cb.onClear,
+                schedulerOpts,
+                resolveTableMode,
+            }),
+        });
+    }
+    if (config.channels.whatsapp) {
+        const { phoneId } = config.channels.whatsapp;
+        const resolveTableMode = () => resolveMarkdownTableMode({ channel: "whatsapp", channelTableMode: cb.getChannelTableConfig("whatsapp") });
+        specs.push({
+            name: "whatsapp",
+            fingerprint: channelFingerprint(phoneId),
+            create: () => createWhatsAppChannel({
+                phoneId,
+                selfOnly: config.channels.whatsapp?.selfOnly,
+                defaultTeamId: DEFAULT_TEAM_ID,
+                listTeams: cb.listTeams,
+                onMessage: cb.onMessage,
+                onClear: cb.onClear,
+                resolveTableMode,
+            }),
+        });
+    }
+    return specs;
+}

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

@@ -0,0 +1,18 @@
+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 CreateTelegramChannelOpts {
+    token: string;
+    onMessage: MessageHandler;
+    onClear?: (channelType: string, channelId: string, teamId?: string) => Promise<void>;
+    /** List available teams for the /team command. */
+    listTeams?: () => {
+        id: string;
+        name: string;
+    }[];
+    /** Fallback team when no active team is set for a chat. */
+    defaultTeamId?: string;
+    resolveTableMode?: ResolveTableMode;
+}
+export declare function createTelegramChannel(opts: CreateTelegramChannelOpts): Channel;