opencode-router 0.11.77 → 0.11.79

package/dist/slack.js

@@ -0,0 +1,169 @@
+import { SocketModeClient } from "@slack/socket-mode";
+import { WebClient } from "@slack/web-api";
+// `peerId` encoding:
+// - DMs:   D12345678
+// - Threads in channels: C12345678|1700000000.000100
+// Using `|` avoids clashing with ALLOW_FROM's channel:peer parsing.
+export function formatSlackPeerId(peer) {
+    if (!peer.threadTs)
+        return peer.channelId;
+    return `${peer.channelId}|${peer.threadTs}`;
+}
+export function parseSlackPeerId(peerId) {
+    const trimmed = peerId.trim();
+    if (!trimmed)
+        return { channelId: "" };
+    const [channelId, threadTs] = trimmed.split("|");
+    if (channelId && threadTs)
+        return { channelId, threadTs };
+    return { channelId: channelId || trimmed };
+}
+export function stripSlackMention(text, botUserId) {
+    let next = text ?? "";
+    if (botUserId) {
+        const token = `<@${botUserId}>`;
+        next = next.split(token).join(" ");
+    }
+    next = next.replace(/^\s*[:,-]+\s*/, "");
+    return next.trim();
+}
+const MAX_TEXT_LENGTH = 39_000;
+export function createSlackAdapter(identity, config, logger, onMessage, deps = { WebClient, SocketModeClient }) {
+    const botToken = identity.botToken?.trim() ?? "";
+    const appToken = identity.appToken?.trim() ?? "";
+    if (!botToken) {
+        throw new Error("Slack bot token is required for Slack adapter");
+    }
+    if (!appToken) {
+        throw new Error("Slack app token is required for Slack adapter");
+    }
+    const log = logger.child({ channel: "slack", identityId: identity.id });
+    const web = new deps.WebClient(botToken);
+    const socket = new deps.SocketModeClient({ appToken });
+    let botUserId = null;
+    let started = false;
+    const safeAck = async (ack) => {
+        if (typeof ack !== "function")
+            return;
+        try {
+            await ack();
+        }
+        catch (error) {
+            log.warn({ error }, "slack ack failed");
+        }
+    };
+    const shouldIgnore = (event) => {
+        const channelId = typeof event.channel === "string" ? event.channel : "";
+        const textRaw = typeof event.text === "string" ? event.text : "";
+        const userId = typeof event.user === "string" ? event.user : null;
+        const botId = typeof event.bot_id === "string" ? event.bot_id : null;
+        const subtype = typeof event.subtype === "string" ? event.subtype : null;
+        // Avoid loops / non-user messages.
+        if (botId)
+            return { ok: true };
+        if (subtype && subtype !== "")
+            return { ok: true };
+        if (userId && botUserId && userId === botUserId)
+            return { ok: true };
+        if (!channelId || !textRaw.trim())
+            return { ok: true };
+        return { ok: false, channelId, textRaw, userId };
+    };
+    socket.on("message", async (args) => {
+        const ack = args?.ack;
+        await safeAck(ack);
+        const event = args?.event;
+        if (!event || typeof event !== "object")
+            return;
+        const filtered = shouldIgnore(event);
+        if (filtered.ok)
+            return;
+        // Only respond to direct messages by default.
+        const isDm = filtered.channelId.startsWith("D");
+        if (!isDm)
+            return;
+        const threadTs = typeof event.thread_ts === "string" ? event.thread_ts : null;
+        const peerId = formatSlackPeerId({ channelId: filtered.channelId, ...(threadTs ? { threadTs } : {}) });
+        try {
+            await onMessage({
+                channel: "slack",
+                identityId: identity.id,
+                peerId,
+                text: filtered.textRaw.trim(),
+                raw: event,
+            });
+        }
+        catch (error) {
+            log.error({ error, peerId }, "slack inbound handler failed");
+        }
+    });
+    socket.on("app_mention", async (args) => {
+        const ack = args?.ack;
+        await safeAck(ack);
+        const event = args?.event;
+        if (!event || typeof event !== "object")
+            return;
+        const filtered = shouldIgnore(event);
+        if (filtered.ok)
+            return;
+        const threadTs = typeof event.thread_ts === "string" ? event.thread_ts : null;
+        const ts = typeof event.ts === "string" ? event.ts : null;
+        const rootThread = threadTs || ts;
+        const peerId = formatSlackPeerId({ channelId: filtered.channelId, ...(rootThread ? { threadTs: rootThread } : {}) });
+        const text = stripSlackMention(filtered.textRaw, botUserId);
+        if (!text)
+            return;
+        try {
+            await onMessage({
+                channel: "slack",
+                identityId: identity.id,
+                peerId,
+                text,
+                raw: event,
+            });
+        }
+        catch (error) {
+            log.error({ error, peerId }, "slack inbound handler failed");
+        }
+    });
+    return {
+        name: "slack",
+        identityId: identity.id,
+        maxTextLength: MAX_TEXT_LENGTH,
+        async start() {
+            if (started)
+                return;
+            log.debug("slack adapter starting");
+            const auth = await web.auth.test();
+            botUserId = typeof auth?.user_id === "string" ? auth.user_id : null;
+            await socket.start();
+            started = true;
+            log.info({ botUserId }, "slack adapter started");
+        },
+        async stop() {
+            if (!started)
+                return;
+            started = false;
+            try {
+                // socket-mode client uses a websocket; disconnect when stopping.
+                await socket.disconnect();
+            }
+            catch (error) {
+                log.warn({ error }, "slack adapter stop failed");
+            }
+            log.info("slack adapter stopped");
+        },
+        async sendText(peerId, text) {
+            const peer = parseSlackPeerId(peerId);
+            if (!peer.channelId)
+                throw new Error("Invalid Slack peerId");
+            const payload = {
+                channel: peer.channelId,
+                text,
+            };
+            if (peer.threadTs)
+                payload.thread_ts = peer.threadTs;
+            await web.chat.postMessage(payload);
+        },
+    };
+}

package/dist/telegram.js

@@ -0,0 +1,78 @@
+import { Bot } from "grammy";
+const MAX_TEXT_LENGTH = 4096;
+export function createTelegramAdapter(identity, config, logger, onMessage) {
+    const token = identity.token?.trim() ?? "";
+    if (!token) {
+        throw new Error("Telegram token is required for Telegram adapter");
+    }
+    const log = logger.child({ channel: "telegram", identityId: identity.id });
+    log.debug({ tokenPresent: true }, "telegram adapter init");
+    const bot = new Bot(token);
+    bot.catch((err) => {
+        log.error({ error: err.error }, "telegram bot error");
+    });
+    bot.on("message", async (ctx) => {
+        const msg = ctx.message;
+        if (!msg?.chat)
+            return;
+        const chatType = msg.chat.type;
+        const isGroup = chatType === "group" || chatType === "supergroup" || chatType === "channel";
+        // In groups, check if groups are enabled
+        if (isGroup && !config.groupsEnabled) {
+            log.debug({ chatId: msg.chat.id, chatType }, "telegram message ignored (groups disabled)");
+            return;
+        }
+        let text = msg.text ?? msg.caption ?? "";
+        if (!text.trim())
+            return;
+        // In groups, only respond if the bot is @mentioned
+        if (isGroup) {
+            const botUsername = ctx.me?.username;
+            if (!botUsername) {
+                log.debug({ chatId: msg.chat.id }, "telegram message ignored (bot username unknown)");
+                return;
+            }
+            const mentionPattern = new RegExp(`@${botUsername}\\b`, "i");
+            if (!mentionPattern.test(text)) {
+                log.debug({ chatId: msg.chat.id, botUsername }, "telegram message ignored (not mentioned)");
+                return;
+            }
+            // Strip the @mention from the message
+            text = text.replace(mentionPattern, "").trim();
+            if (!text) {
+                log.debug({ chatId: msg.chat.id }, "telegram message ignored (empty after removing mention)");
+                return;
+            }
+        }
+        log.debug({ chatId: msg.chat.id, chatType, isGroup, length: text.length, preview: text.slice(0, 120) }, "telegram message received");
+        try {
+            await onMessage({
+                channel: "telegram",
+                identityId: identity.id,
+                peerId: String(msg.chat.id),
+                text,
+                raw: msg,
+            });
+        }
+        catch (error) {
+            log.error({ error, peerId: msg.chat.id }, "telegram inbound handler failed");
+        }
+    });
+    return {
+        name: "telegram",
+        identityId: identity.id,
+        maxTextLength: MAX_TEXT_LENGTH,
+        async start() {
+            log.debug("telegram adapter starting");
+            await bot.start();
+            log.info("telegram adapter started");
+        },
+        async stop() {
+            bot.stop();
+            log.info("telegram adapter stopped");
+        },
+        async sendText(peerId, text) {
+            await bot.api.sendMessage(Number(peerId), text);
+        },
+    };
+}

package/dist/text.js

@@ -0,0 +1,41 @@
+export function chunkText(input, limit) {
+    if (input.length <= limit)
+        return [input];
+    const chunks = [];
+    let current = "";
+    for (const line of input.split(/\n/)) {
+        if ((current + line).length + 1 > limit) {
+            if (current)
+                chunks.push(current.trimEnd());
+            current = "";
+        }
+        if (line.length > limit) {
+            for (let i = 0; i < line.length; i += limit) {
+                const slice = line.slice(i, i + limit);
+                if (slice.length)
+                    chunks.push(slice);
+            }
+            continue;
+        }
+        current += current ? `\n${line}` : line;
+    }
+    if (current.trim().length)
+        chunks.push(current.trimEnd());
+    return chunks.length ? chunks : [input];
+}
+export function truncateText(text, limit) {
+    if (text.length <= limit)
+        return text;
+    return `${text.slice(0, Math.max(0, limit - 1))}…`;
+}
+export function formatInputSummary(input) {
+    const entries = Object.entries(input);
+    if (!entries.length)
+        return "";
+    try {
+        return JSON.stringify(input);
+    }
+    catch {
+        return entries.map(([key, value]) => `${key}=${String(value)}`).join(", ");
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-router",
-  "version": "0.11.77",
+  "version": "0.11.79",
   "description": "opencode-router: Slack + Telegram bridge + directory routing for a running opencode server",
   "private": false,
   "type": "module",