@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/channels/plugins/normalize/imessage.js

@@ -4,18 +4,21 @@ const SERVICE_PREFIXES = ["imessage:", "sms:", "auto:"];
 const CHAT_TARGET_PREFIX_RE = /^(chat_id:|chatid:|chat:|chat_guid:|chatguid:|guid:|chat_identifier:|chatidentifier:|chatident:)/i;
 export function normalizeIMessageMessagingTarget(raw) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return undefined;
+    }
     // Preserve service prefix if present (e.g., "sms:+1555" → "sms:+15551234567")
     const lower = trimmed.toLowerCase();
     for (const prefix of SERVICE_PREFIXES) {
         if (lower.startsWith(prefix)) {
             const remainder = trimmed.slice(prefix.length).trim();
             const normalizedHandle = normalizeIMessageHandle(remainder);
-            if (!normalizedHandle)
+            if (!normalizedHandle) {
                 return undefined;
-            if (CHAT_TARGET_PREFIX_RE.test(normalizedHandle))
+            }
+            if (CHAT_TARGET_PREFIX_RE.test(normalizedHandle)) {
                 return normalizedHandle;
+            }
             return `${prefix}${normalizedHandle}`;
         }
     }
@@ -24,13 +27,17 @@ export function normalizeIMessageMessagingTarget(raw) {
 }
 export function looksLikeIMessageTargetId(raw) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return false;
-    if (/^(imessage:|sms:|auto:)/i.test(trimmed))
+    }
+    if (/^(imessage:|sms:|auto:)/i.test(trimmed)) {
         return true;
-    if (CHAT_TARGET_PREFIX_RE.test(trimmed))
+    }
+    if (CHAT_TARGET_PREFIX_RE.test(trimmed)) {
         return true;
-    if (trimmed.includes("@"))
+    }
+    if (trimmed.includes("@")) {
         return true;
+    }
     return /^\+?\d{3,}$/.test(trimmed);
 }

package/dist/channels/plugins/normalize/slack.js

@@ -5,15 +5,20 @@ export function normalizeSlackMessagingTarget(raw) {
 }
 export function looksLikeSlackTargetId(raw) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return false;
-    if (/^<@([A-Z0-9]+)>$/i.test(trimmed))
+    }
+    if (/^<@([A-Z0-9]+)>$/i.test(trimmed)) {
         return true;
-    if (/^(user|channel):/i.test(trimmed))
+    }
+    if (/^(user|channel):/i.test(trimmed)) {
         return true;
-    if (/^slack:/i.test(trimmed))
+    }
+    if (/^slack:/i.test(trimmed)) {
         return true;
-    if (/^[@#]/.test(trimmed))
+    }
+    if (/^[@#]/.test(trimmed)) {
         return true;
+    }
     return /^[CUWGD][A-Z0-9]{8,}$/i.test(trimmed);
 }

package/dist/channels/plugins/normalize/telegram.js

@@ -1,7 +1,8 @@
 export function normalizeTelegramMessagingTarget(raw) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return undefined;
+    }
     let normalized = trimmed;
     if (normalized.startsWith("telegram:")) {
         normalized = normalized.slice("telegram:".length).trim();
@@ -9,23 +10,29 @@ export function normalizeTelegramMessagingTarget(raw) {
     else if (normalized.startsWith("tg:")) {
         normalized = normalized.slice("tg:".length).trim();
     }
-    if (!normalized)
+    if (!normalized) {
         return undefined;
+    }
     const tmeMatch = /^https?:\/\/t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized) ??
         /^t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized);
-    if (tmeMatch?.[1])
+    if (tmeMatch?.[1]) {
         normalized = `@${tmeMatch[1]}`;
-    if (!normalized)
+    }
+    if (!normalized) {
         return undefined;
+    }
     return `telegram:${normalized}`.toLowerCase();
 }
 export function looksLikeTelegramTargetId(raw) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return false;
-    if (/^(telegram|tg):/i.test(trimmed))
+    }
+    if (/^(telegram|tg):/i.test(trimmed)) {
         return true;
-    if (trimmed.startsWith("@"))
+    }
+    if (trimmed.startsWith("@")) {
         return true;
+    }
     return /^-?\d{6,}$/.test(trimmed);
 }

package/dist/channels/plugins/outbound/discord.js

@@ -1,29 +1,101 @@
-import { sendMessageDiscord, sendPollDiscord } from "../../../discord/send.js";
+import { getThreadBindingManager, } from "../../../discord/monitor/thread-bindings.js";
+import { sendMessageDiscord, sendPollDiscord, sendWebhookMessageDiscord, } from "../../../discord/send.js";
+import { normalizeDiscordOutboundTarget } from "../normalize/discord.js";
+function resolveDiscordOutboundTarget(params) {
+    if (params.threadId == null) {
+        return params.to;
+    }
+    const threadId = String(params.threadId).trim();
+    if (!threadId) {
+        return params.to;
+    }
+    return `channel:${threadId}`;
+}
+function resolveDiscordWebhookIdentity(params) {
+    const usernameRaw = params.identity?.name?.trim();
+    const fallbackUsername = params.binding.label?.trim() || params.binding.agentId;
+    const username = (usernameRaw || fallbackUsername || "").slice(0, 80) || undefined;
+    const avatarUrl = params.identity?.avatarUrl?.trim() || undefined;
+    return { username, avatarUrl };
+}
+async function maybeSendDiscordWebhookText(params) {
+    if (params.threadId == null) {
+        return null;
+    }
+    const threadId = String(params.threadId).trim();
+    if (!threadId) {
+        return null;
+    }
+    const manager = getThreadBindingManager(params.accountId ?? undefined);
+    if (!manager) {
+        return null;
+    }
+    const binding = manager.getByThreadId(threadId);
+    if (!binding?.webhookId || !binding?.webhookToken) {
+        return null;
+    }
+    const persona = resolveDiscordWebhookIdentity({
+        identity: params.identity,
+        binding,
+    });
+    const result = await sendWebhookMessageDiscord(params.text, {
+        webhookId: binding.webhookId,
+        webhookToken: binding.webhookToken,
+        accountId: binding.accountId,
+        threadId: binding.threadId,
+        replyTo: params.replyToId ?? undefined,
+        username: persona.username,
+        avatarUrl: persona.avatarUrl,
+    });
+    return result;
+}
 export const discordOutbound = {
     deliveryMode: "direct",
     chunker: null,
     textChunkLimit: 2000,
     pollMaxOptions: 10,
-    sendText: async ({ to, text, accountId, deps, replyToId }) => {
+    resolveTarget: ({ to }) => normalizeDiscordOutboundTarget(to),
+    sendText: async ({ to, text, accountId, deps, replyToId, threadId, identity, silent }) => {
+        if (!silent) {
+            const webhookResult = await maybeSendDiscordWebhookText({
+                text,
+                threadId,
+                accountId,
+                identity,
+                replyToId,
+            }).catch(() => null);
+            if (webhookResult) {
+                return { channel: "discord", ...webhookResult };
+            }
+        }
         const send = deps?.sendDiscord ?? sendMessageDiscord;
-        const result = await send(to, text, {
+        const target = resolveDiscordOutboundTarget({ to, threadId });
+        const result = await send(target, text, {
             verbose: false,
             replyTo: replyToId ?? undefined,
             accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
         });
         return { channel: "discord", ...result };
     },
-    sendMedia: async ({ to, text, mediaUrl, accountId, deps, replyToId }) => {
+    sendMedia: async ({ to, text, mediaUrl, mediaLocalRoots, accountId, deps, replyToId, threadId, silent, }) => {
         const send = deps?.sendDiscord ?? sendMessageDiscord;
-        const result = await send(to, text, {
+        const target = resolveDiscordOutboundTarget({ to, threadId });
+        const result = await send(target, text, {
             verbose: false,
             mediaUrl,
+            mediaLocalRoots,
             replyTo: replyToId ?? undefined,
             accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
         });
         return { channel: "discord", ...result };
     },
-    sendPoll: async ({ to, poll, accountId }) => await sendPollDiscord(to, poll, {
-        accountId: accountId ?? undefined,
-    }),
+    sendPoll: async ({ to, poll, accountId, threadId, silent }) => {
+        const target = resolveDiscordOutboundTarget({ to, threadId });
+        return await sendPollDiscord(target, poll, {
+            accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
+        });
+    },
 };

package/dist/channels/plugins/outbound/signal.js

@@ -1,6 +1,13 @@
 import { chunkText } from "../../../auto-reply/chunk.js";
 import { sendMessageSignal } from "../../../signal/send.js";
 import { resolveChannelMediaMaxBytes } from "../media-limits.js";
+function resolveSignalMaxBytes(params) {
+    return resolveChannelMediaMaxBytes({
+        cfg: params.cfg,
+        resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.signal?.accounts?.[accountId]?.mediaMaxMb ?? cfg.channels?.signal?.mediaMaxMb,
+        accountId: params.accountId,
+    });
+}
 export const signalOutbound = {
     deliveryMode: "direct",
     chunker: chunkText,
@@ -8,28 +15,21 @@ export const signalOutbound = {
     textChunkLimit: 4000,
     sendText: async ({ cfg, to, text, accountId, deps }) => {
         const send = deps?.sendSignal ?? sendMessageSignal;
-        const maxBytes = resolveChannelMediaMaxBytes({
-            cfg,
-            resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.signal?.accounts?.[accountId]?.mediaMaxMb ?? cfg.channels?.signal?.mediaMaxMb,
-            accountId,
-        });
+        const maxBytes = resolveSignalMaxBytes({ cfg, accountId });
         const result = await send(to, text, {
             maxBytes,
             accountId: accountId ?? undefined,
         });
         return { channel: "signal", ...result };
     },
-    sendMedia: async ({ cfg, to, text, mediaUrl, accountId, deps }) => {
+    sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, accountId, deps }) => {
         const send = deps?.sendSignal ?? sendMessageSignal;
-        const maxBytes = resolveChannelMediaMaxBytes({
-            cfg,
-            resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.signal?.accounts?.[accountId]?.mediaMaxMb ?? cfg.channels?.signal?.mediaMaxMb,
-            accountId,
-        });
+        const maxBytes = resolveSignalMaxBytes({ cfg, accountId });
         const result = await send(to, text, {
             mediaUrl,
             maxBytes,
             accountId: accountId ?? undefined,
+            mediaLocalRoots,
         });
         return { channel: "signal", ...result };
     },

package/dist/channels/plugins/setup-helpers.js

@@ -5,16 +5,19 @@ function channelHasAccounts(cfg, channelKey) {
     return Boolean(base?.accounts && Object.keys(base.accounts).length > 0);
 }
 function shouldStoreNameInAccounts(params) {
-    if (params.alwaysUseAccounts)
+    if (params.alwaysUseAccounts) {
         return true;
-    if (params.accountId !== DEFAULT_ACCOUNT_ID)
+    }
+    if (params.accountId !== DEFAULT_ACCOUNT_ID) {
         return true;
+    }
     return channelHasAccounts(params.cfg, params.channelKey);
 }
 export function applyAccountNameToChannelSection(params) {
     const trimmed = params.name?.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return params.cfg;
+    }
     const accountId = normalizeAccountId(params.accountId);
     const channels = params.cfg.channels;
     const baseConfig = channels?.[params.channelKey];
@@ -61,13 +64,15 @@ export function applyAccountNameToChannelSection(params) {
     };
 }
 export function migrateBaseNameToDefaultAccount(params) {
-    if (params.alwaysUseAccounts)
+    if (params.alwaysUseAccounts) {
         return params.cfg;
+    }
     const channels = params.cfg.channels;
     const base = channels?.[params.channelKey];
     const baseName = base?.name?.trim();
-    if (!baseName)
+    if (!baseName) {
         return params.cfg;
+    }
     const accounts = {
         ...base?.accounts,
     };

package/dist/channels/sender-label.js

@@ -10,8 +10,9 @@ export function resolveSenderLabel(params) {
     const id = normalize(params.id);
     const display = name ?? username ?? tag ?? "";
     const idPart = e164 ?? id ?? "";
-    if (display && idPart && display !== idPart)
+    if (display && idPart && display !== idPart) {
         return `${display} (${idPart})`;
+    }
     return display || idPart || null;
 }
 export function listSenderLabelCandidates(params) {
@@ -21,18 +22,24 @@ export function listSenderLabelCandidates(params) {
     const tag = normalize(params.tag);
     const e164 = normalize(params.e164);
     const id = normalize(params.id);
-    if (name)
+    if (name) {
         candidates.add(name);
-    if (username)
+    }
+    if (username) {
         candidates.add(username);
-    if (tag)
+    }
+    if (tag) {
         candidates.add(tag);
-    if (e164)
+    }
+    if (e164) {
         candidates.add(e164);
-    if (id)
+    }
+    if (id) {
         candidates.add(id);
+    }
     const resolved = resolveSenderLabel(params);
-    if (resolved)
+    if (resolved) {
         candidates.add(resolved);
+    }
     return Array.from(candidates);
 }

package/dist/channels/session.js

@@ -9,8 +9,9 @@ export async function recordInboundSession(params) {
         createIfMissing,
     }).catch(params.onRecordError);
     const update = params.updateLastRoute;
-    if (!update)
+    if (!update) {
         return;
+    }
     await updateLastRoute({
         storePath,
         sessionKey: update.sessionKey,
@@ -20,7 +21,8 @@ export async function recordInboundSession(params) {
             accountId: update.accountId,
             threadId: update.threadId,
         },
-        ctx,
+        // Avoid leaking inbound origin metadata into a different target session.
+        ctx: update.sessionKey === sessionKey ? ctx : undefined,
         groupResolution,
     });
 }

package/dist/channels/status-reactions.js

@@ -0,0 +1,297 @@
+/**
+ * Channel-agnostic status reaction controller.
+ * Provides a unified interface for displaying agent status via message reactions.
+ */
+// ─────────────────────────────────────────────────────────────────────────────
+// Constants
+// ─────────────────────────────────────────────────────────────────────────────
+export const DEFAULT_EMOJIS = {
+    queued: "👀",
+    thinking: "🤔",
+    tool: "🔥",
+    coding: "👨‍💻",
+    web: "⚡",
+    done: "👍",
+    error: "😱",
+    stallSoft: "🥱",
+    stallHard: "😨",
+};
+export const DEFAULT_TIMING = {
+    debounceMs: 700,
+    stallSoftMs: 10_000,
+    stallHardMs: 30_000,
+    doneHoldMs: 1500,
+    errorHoldMs: 2500,
+};
+export const CODING_TOOL_TOKENS = [
+    "exec",
+    "process",
+    "read",
+    "write",
+    "edit",
+    "session_status",
+    "bash",
+];
+export const WEB_TOOL_TOKENS = [
+    "web_search",
+    "web-search",
+    "web_fetch",
+    "web-fetch",
+    "browser",
+];
+// ─────────────────────────────────────────────────────────────────────────────
+// Functions
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Resolve the appropriate emoji for a tool invocation.
+ */
+export function resolveToolEmoji(toolName, emojis) {
+    const normalized = toolName?.trim().toLowerCase() ?? "";
+    if (!normalized) {
+        return emojis.tool;
+    }
+    if (WEB_TOOL_TOKENS.some((token) => normalized.includes(token))) {
+        return emojis.web;
+    }
+    if (CODING_TOOL_TOKENS.some((token) => normalized.includes(token))) {
+        return emojis.coding;
+    }
+    return emojis.tool;
+}
+/**
+ * Create a status reaction controller.
+ *
+ * Features:
+ * - Promise chain serialization (prevents concurrent API calls)
+ * - Debouncing (intermediate states debounce, terminal states are immediate)
+ * - Stall timers (soft/hard warnings on inactivity)
+ * - Terminal state protection (done/error mark finished, subsequent updates ignored)
+ */
+export function createStatusReactionController(params) {
+    const { enabled, adapter, initialEmoji, onError } = params;
+    // Merge user-provided overrides with defaults
+    const emojis = {
+        ...DEFAULT_EMOJIS,
+        queued: params.emojis?.queued ?? initialEmoji,
+        ...params.emojis,
+    };
+    const timing = {
+        ...DEFAULT_TIMING,
+        ...params.timing,
+    };
+    // State
+    let currentEmoji = "";
+    let pendingEmoji = "";
+    let debounceTimer = null;
+    let stallSoftTimer = null;
+    let stallHardTimer = null;
+    let finished = false;
+    let chainPromise = Promise.resolve();
+    // Known emojis for clear operation
+    const knownEmojis = new Set([
+        initialEmoji,
+        emojis.queued,
+        emojis.thinking,
+        emojis.tool,
+        emojis.coding,
+        emojis.web,
+        emojis.done,
+        emojis.error,
+        emojis.stallSoft,
+        emojis.stallHard,
+    ]);
+    /**
+     * Serialize async operations to prevent race conditions.
+     */
+    function enqueue(fn) {
+        chainPromise = chainPromise.then(fn, fn);
+        return chainPromise;
+    }
+    /**
+     * Clear all timers.
+     */
+    function clearAllTimers() {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+            debounceTimer = null;
+        }
+        if (stallSoftTimer) {
+            clearTimeout(stallSoftTimer);
+            stallSoftTimer = null;
+        }
+        if (stallHardTimer) {
+            clearTimeout(stallHardTimer);
+            stallHardTimer = null;
+        }
+    }
+    /**
+     * Clear debounce timer only (used during phase transitions).
+     */
+    function clearDebounceTimer() {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+            debounceTimer = null;
+        }
+    }
+    /**
+     * Reset stall timers (called on each phase change).
+     */
+    function resetStallTimers() {
+        if (stallSoftTimer) {
+            clearTimeout(stallSoftTimer);
+        }
+        if (stallHardTimer) {
+            clearTimeout(stallHardTimer);
+        }
+        stallSoftTimer = setTimeout(() => {
+            scheduleEmoji(emojis.stallSoft, { immediate: true, skipStallReset: true });
+        }, timing.stallSoftMs);
+        stallHardTimer = setTimeout(() => {
+            scheduleEmoji(emojis.stallHard, { immediate: true, skipStallReset: true });
+        }, timing.stallHardMs);
+    }
+    /**
+     * Apply an emoji: set new reaction and optionally remove old one.
+     */
+    async function applyEmoji(newEmoji) {
+        if (!enabled) {
+            return;
+        }
+        try {
+            const previousEmoji = currentEmoji;
+            await adapter.setReaction(newEmoji);
+            // If adapter supports removeReaction and there's a different previous emoji, remove it
+            if (adapter.removeReaction && previousEmoji && previousEmoji !== newEmoji) {
+                await adapter.removeReaction(previousEmoji);
+            }
+            currentEmoji = newEmoji;
+        }
+        catch (err) {
+            if (onError) {
+                onError(err);
+            }
+        }
+    }
+    /**
+     * Schedule an emoji change (debounced or immediate).
+     */
+    function scheduleEmoji(emoji, options = {}) {
+        if (!enabled || finished) {
+            return;
+        }
+        // Deduplicate: if already scheduled/current, skip send but keep stall timers fresh
+        if (emoji === currentEmoji || emoji === pendingEmoji) {
+            if (!options.skipStallReset) {
+                resetStallTimers();
+            }
+            return;
+        }
+        pendingEmoji = emoji;
+        clearDebounceTimer();
+        if (options.immediate) {
+            // Immediate execution for terminal states
+            void enqueue(async () => {
+                await applyEmoji(emoji);
+                pendingEmoji = "";
+            });
+        }
+        else {
+            // Debounced execution for intermediate states
+            debounceTimer = setTimeout(() => {
+                void enqueue(async () => {
+                    await applyEmoji(emoji);
+                    pendingEmoji = "";
+                });
+            }, timing.debounceMs);
+        }
+        // Reset stall timers on phase change (unless triggered by stall timer itself)
+        if (!options.skipStallReset) {
+            resetStallTimers();
+        }
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Controller API
+    // ───────────────────────────────────────────────────────────────────────────
+    function setQueued() {
+        scheduleEmoji(emojis.queued, { immediate: true });
+    }
+    function setThinking() {
+        scheduleEmoji(emojis.thinking);
+    }
+    function setTool(toolName) {
+        const emoji = resolveToolEmoji(toolName, emojis);
+        scheduleEmoji(emoji);
+    }
+    function setDone() {
+        if (!enabled) {
+            return Promise.resolve();
+        }
+        finished = true;
+        clearAllTimers();
+        // Directly enqueue to ensure we return the updated promise
+        return enqueue(async () => {
+            await applyEmoji(emojis.done);
+            pendingEmoji = "";
+        });
+    }
+    function setError() {
+        if (!enabled) {
+            return Promise.resolve();
+        }
+        finished = true;
+        clearAllTimers();
+        // Directly enqueue to ensure we return the updated promise
+        return enqueue(async () => {
+            await applyEmoji(emojis.error);
+            pendingEmoji = "";
+        });
+    }
+    async function clear() {
+        if (!enabled) {
+            return;
+        }
+        clearAllTimers();
+        finished = true;
+        await enqueue(async () => {
+            if (adapter.removeReaction) {
+                // Remove all known emojis (Discord-style)
+                const emojisToRemove = Array.from(knownEmojis);
+                for (const emoji of emojisToRemove) {
+                    try {
+                        await adapter.removeReaction(emoji);
+                    }
+                    catch (err) {
+                        if (onError) {
+                            onError(err);
+                        }
+                    }
+                }
+            }
+            else {
+                // For platforms without removeReaction, set empty or just skip
+                // (Telegram handles this atomically on the next setReaction)
+            }
+            currentEmoji = "";
+            pendingEmoji = "";
+        });
+    }
+    async function restoreInitial() {
+        if (!enabled) {
+            return;
+        }
+        clearAllTimers();
+        await enqueue(async () => {
+            await applyEmoji(initialEmoji);
+            pendingEmoji = "";
+        });
+    }
+    return {
+        setQueued,
+        setThinking,
+        setTool,
+        setDone,
+        setError,
+        clear,
+        restoreInitial,
+    };
+}