@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/signal/monitor/event-handler.js

@@ -1,19 +1,21 @@
 import { resolveHumanDelayConfig } from "../../agents/identity.js";
 import { hasControlCommand } from "../../auto-reply/command-detection.js";
+import { dispatchInboundMessage } from "../../auto-reply/dispatch.js";
 import { formatInboundEnvelope, formatInboundFromLabel, resolveEnvelopeFormatOptions, } from "../../auto-reply/envelope.js";
 import { createInboundDebouncer, resolveInboundDebounceMs, } from "../../auto-reply/inbound-debounce.js";
-import { dispatchInboundMessage } from "../../auto-reply/dispatch.js";
 import { buildPendingHistoryContextFromMap, clearHistoryEntriesIfEnabled, recordPendingHistoryEntryIfEnabled, } from "../../auto-reply/reply/history.js";
-import { buildMentionRegexes, matchesMentionPatterns } from "../../auto-reply/reply/mentions.js";
 import { finalizeInboundContext } from "../../auto-reply/reply/inbound-context.js";
+import { buildMentionRegexes, matchesMentionPatterns } from "../../auto-reply/reply/mentions.js";
 import { createReplyDispatcherWithTyping } from "../../auto-reply/reply/reply-dispatcher.js";
+import { resolveControlCommandGate } from "../../channels/command-gating.js";
 import { logInboundDrop, logTypingFailure } from "../../channels/logging.js";
 import { resolveMentionGatingWithBypass } from "../../channels/mention-gating.js";
-import { createReplyPrefixContext } from "../../channels/reply-prefix.js";
+import { normalizeSignalMessagingTarget } from "../../channels/plugins/normalize/signal.js";
+import { createReplyPrefixOptions } from "../../channels/reply-prefix.js";
 import { recordInboundSession } from "../../channels/session.js";
 import { createTypingCallbacks } from "../../channels/typing.js";
-import { readSessionUpdatedAt, resolveStorePath } from "../../config/sessions.js";
 import { resolveChannelGroupRequireMention } from "../../config/group-policy.js";
+import { readSessionUpdatedAt, resolveStorePath } from "../../config/sessions.js";
 import { danger, logVerbose, shouldLogVerbose } from "../../globals.js";
 import { enqueueSystemEvent } from "../../infra/system-events.js";
 import { mediaKindFromMime } from "../../media/constants.js";
@@ -21,9 +23,9 @@ import { buildPairingReply } from "../../pairing/pairing-messages.js";
 import { readChannelAllowFromStore, upsertChannelPairingRequest, } from "../../pairing/pairing-store.js";
 import { resolveAgentRoute } from "../../routing/resolve-route.js";
 import { normalizeE164 } from "../../utils.js";
-import { resolveControlCommandGate } from "../../channels/command-gating.js";
 import { formatSignalPairingIdLine, formatSignalSenderDisplay, formatSignalSenderId, isSignalSenderAllowed, resolveSignalPeerId, resolveSignalRecipient, resolveSignalSender, } from "../identity.js";
 import { sendMessageSignal, sendReadReceiptSignal, sendTypingSignal } from "../send.js";
+import { renderSignalMentions } from "./mentions.js";
 export function createSignalEventHandler(deps) {
     const inboundDebounceMs = resolveInboundDebounceMs({ cfg: deps.cfg, channel: "signal" });
     async function handleSignalInboundMessage(entry) {
@@ -40,7 +42,7 @@ export function createSignalEventHandler(deps) {
             channel: "signal",
             accountId: deps.accountId,
             peer: {
-                kind: entry.isGroup ? "group" : "dm",
+                kind: entry.isGroup ? "group" : "direct",
                 id: entry.isGroup ? (entry.groupId ?? "unknown") : entry.senderPeerId,
             },
         });
@@ -81,7 +83,10 @@ export function createSignalEventHandler(deps) {
                 }),
             });
         }
-        const signalTo = entry.isGroup ? `group:${entry.groupId}` : `signal:${entry.senderRecipient}`;
+        const signalToRaw = entry.isGroup
+            ? `group:${entry.groupId}`
+            : `signal:${entry.senderRecipient}`;
+        const signalTo = normalizeSignalMessagingTarget(signalToRaw) ?? signalToRaw;
         const inboundHistory = entry.isGroup && historyKey && deps.historyLimit > 0
             ? (deps.groupHistories.get(historyKey) ?? []).map((historyEntry) => ({
                 sender: historyEntry.sender,
@@ -138,11 +143,17 @@ export function createSignalEventHandler(deps) {
             const preview = body.slice(0, 200).replace(/\\n/g, "\\\\n");
             logVerbose(`signal inbound: from=${ctxPayload.From} len=${body.length} preview="${preview}"`);
         }
-        const prefixContext = createReplyPrefixContext({ cfg: deps.cfg, agentId: route.agentId });
+        const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+            cfg: deps.cfg,
+            agentId: route.agentId,
+            channel: "signal",
+            accountId: route.accountId,
+        });
         const typingCallbacks = createTypingCallbacks({
             start: async () => {
-                if (!ctxPayload.To)
+                if (!ctxPayload.To) {
                     return;
+                }
                 await sendTypingSignal(ctxPayload.To, {
                     baseUrl: deps.baseUrl,
                     account: deps.account,
@@ -159,8 +170,7 @@ export function createSignalEventHandler(deps) {
             },
         });
         const { dispatcher, replyOptions, markDispatchIdle } = createReplyDispatcherWithTyping({
-            responsePrefix: prefixContext.responsePrefix,
-            responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+            ...prefixOptions,
             humanDelay: resolveHumanDelayConfig(deps.cfg, route.agentId),
             deliver: async (payload) => {
                 await deps.deliverReplies({
@@ -186,9 +196,7 @@ export function createSignalEventHandler(deps) {
             replyOptions: {
                 ...replyOptions,
                 disableBlockStreaming: typeof deps.blockStreaming === "boolean" ? !deps.blockStreaming : undefined,
-                onModelSelected: (ctx) => {
-                    prefixContext.onModelSelected(ctx);
-                },
+                onModelSelected,
             },
         });
         markDispatchIdle();
@@ -214,21 +222,25 @@ export function createSignalEventHandler(deps) {
         debounceMs: inboundDebounceMs,
         buildKey: (entry) => {
             const conversationId = entry.isGroup ? (entry.groupId ?? "unknown") : entry.senderPeerId;
-            if (!conversationId || !entry.senderPeerId)
+            if (!conversationId || !entry.senderPeerId) {
                 return null;
+            }
             return `signal:${deps.accountId}:${conversationId}:${entry.senderPeerId}`;
         },
         shouldDebounce: (entry) => {
-            if (!entry.bodyText.trim())
+            if (!entry.bodyText.trim()) {
                 return false;
-            if (entry.mediaPath || entry.mediaType)
+            }
+            if (entry.mediaPath || entry.mediaType) {
                 return false;
+            }
             return !hasControlCommand(entry.bodyText, deps.cfg);
         },
         onFlush: async (entries) => {
             const last = entries.at(-1);
-            if (!last)
+            if (!last) {
                 return;
+            }
             if (entries.length === 1) {
                 await handleSignalInboundMessage(last);
                 return;
@@ -237,8 +249,9 @@ export function createSignalEventHandler(deps) {
                 .map((entry) => entry.bodyText)
                 .filter(Boolean)
                 .join("\\n");
-            if (!combinedText.trim())
+            if (!combinedText.trim()) {
                 return;
+            }
             await handleSignalInboundMessage({
                 ...last,
                 bodyText: combinedText,
@@ -251,8 +264,9 @@ export function createSignalEventHandler(deps) {
         },
     });
     return async (event) => {
-        if (event.event !== "receive" || !event.data)
+        if (event.event !== "receive" || !event.data) {
             return;
+        }
         let payload = null;
         try {
             payload = JSON.parse(event.data);
@@ -265,16 +279,20 @@ export function createSignalEventHandler(deps) {
             deps.runtime.error?.(`receive exception: ${payload.exception.message}`);
         }
         const envelope = payload?.envelope;
-        if (!envelope)
+        if (!envelope) {
             return;
-        if (envelope.syncMessage)
+        }
+        if (envelope.syncMessage) {
             return;
+        }
         const sender = resolveSignalSender(envelope);
-        if (!sender)
+        if (!sender) {
             return;
+        }
         if (deps.account && sender.kind === "phone") {
-            if (sender.e164 === normalizeE164(deps.account))
+            if (sender.e164 === normalizeE164(deps.account)) {
                 return;
+            }
         }
         const dataMessage = envelope.dataMessage ?? envelope.editMessage?.dataMessage;
         const reaction = deps.isSignalReactionMessage(envelope.reactionMessage)
@@ -282,12 +300,17 @@ export function createSignalEventHandler(deps) {
             : deps.isSignalReactionMessage(dataMessage?.reaction)
                 ? dataMessage?.reaction
                 : null;
-        const messageText = (dataMessage?.message ?? "").trim();
+        // Replace  (object replacement character) with @uuid or @phone from mentions
+        // Signal encodes mentions as the object replacement character; hydrate them from metadata first.
+        const rawMessage = dataMessage?.message ?? "";
+        const normalizedMessage = renderSignalMentions(rawMessage, dataMessage?.mentions);
+        const messageText = normalizedMessage.trim();
         const quoteText = dataMessage?.quote?.text?.trim() ?? "";
         const hasBodyContent = Boolean(messageText || quoteText) || Boolean(!reaction && dataMessage?.attachments?.length);
         if (reaction && !hasBodyContent) {
-            if (reaction.isRemove)
-                return; // Ignore reaction removals
+            if (reaction.isRemove) {
+                return;
+            } // Ignore reaction removals
             const emojiLabel = reaction.emoji?.trim() || "emoji";
             const senderDisplay = formatSignalSenderDisplay(sender);
             const senderName = envelope.sourceName ?? senderDisplay;
@@ -300,8 +323,9 @@ export function createSignalEventHandler(deps) {
                 sender,
                 allowlist: deps.reactionAllowlist,
             });
-            if (!shouldNotify)
+            if (!shouldNotify) {
                 return;
+            }
             const groupId = reaction.groupInfo?.groupId ?? undefined;
             const groupName = reaction.groupInfo?.groupName ?? undefined;
             const isGroup = Boolean(groupId);
@@ -311,7 +335,7 @@ export function createSignalEventHandler(deps) {
                 channel: "signal",
                 accountId: deps.accountId,
                 peer: {
-                    kind: isGroup ? "group" : "dm",
+                    kind: isGroup ? "group" : "direct",
                     id: isGroup ? (groupId ?? "unknown") : senderPeerId,
                 },
             });
@@ -341,14 +365,16 @@ export function createSignalEventHandler(deps) {
             enqueueSystemEvent(text, { sessionKey: route.sessionKey, contextKey });
             return;
         }
-        if (!dataMessage)
+        if (!dataMessage) {
             return;
+        }
         const senderDisplay = formatSignalSenderDisplay(sender);
         const senderRecipient = resolveSignalRecipient(sender);
         const senderPeerId = resolveSignalPeerId(sender);
         const senderAllowId = formatSignalSenderId(sender);
-        if (!senderRecipient)
+        if (!senderRecipient) {
             return;
+        }
         const senderIdLine = formatSignalPairingIdLine(sender);
         const groupId = dataMessage.groupInfo?.groupId ?? undefined;
         const groupName = dataMessage.groupInfo?.groupName ?? undefined;
@@ -358,8 +384,9 @@ export function createSignalEventHandler(deps) {
         const effectiveGroupAllow = [...deps.groupAllowFrom, ...storeAllowFrom];
         const dmAllowed = deps.dmPolicy === "open" ? true : isSignalSenderAllowed(sender, effectiveDmAllow);
         if (!isGroup) {
-            if (deps.dmPolicy === "disabled")
+            if (deps.dmPolicy === "disabled") {
                 return;
+            }
             if (!dmAllowed) {
                 if (deps.dmPolicy === "pairing") {
                     const senderId = senderAllowId;
@@ -435,7 +462,7 @@ export function createSignalEventHandler(deps) {
             channel: "signal",
             accountId: deps.accountId,
             peer: {
-                kind: isGroup ? "group" : "dm",
+                kind: isGroup ? "group" : "direct",
                 id: isGroup ? (groupId ?? "unknown") : senderPeerId,
             },
         });
@@ -473,6 +500,8 @@ export function createSignalEventHandler(deps) {
                 if (!dataMessage.attachments?.length) {
                     return "";
                 }
+                // When we're skipping a message we intentionally avoid downloading attachments.
+                // Still record a useful placeholder for pending-history context.
                 if (deps.ignoreAttachments) {
                     return "<media:attachment>";
                 }
@@ -519,13 +548,16 @@ export function createSignalEventHandler(deps) {
             }
         }
         const kind = mediaKindFromMime(mediaType ?? undefined);
-        if (kind)
+        if (kind) {
             placeholder = `<media:${kind}>`;
-        else if (dataMessage.attachments?.length)
+        }
+        else if (dataMessage.attachments?.length) {
             placeholder = "<media:attachment>";
+        }
         const bodyText = messageText || placeholder || dataMessage.quote?.text?.trim() || "";
-        if (!bodyText)
+        if (!bodyText) {
             return;
+        }
         const receiptTimestamp = typeof envelope.timestamp === "number"
             ? envelope.timestamp
             : typeof dataMessage.timestamp === "number"

package/dist/signal/send.js

@@ -1,15 +1,16 @@
 import { loadConfig } from "../config/config.js";
 import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
 import { mediaKindFromMime } from "../media/constants.js";
-import { saveMediaBuffer } from "../media/store.js";
-import { loadWebMedia } from "../web/media.js";
+import { resolveOutboundAttachmentFromUrl } from "../media/outbound-attachment.js";
 import { resolveSignalAccount } from "./accounts.js";
 import { signalRpcRequest } from "./client.js";
 import { markdownToSignalText } from "./format.js";
+import { resolveSignalRpcContext } from "./rpc-context.js";
 function parseTarget(raw) {
     let value = raw.trim();
-    if (!value)
+    if (!value) {
         throw new Error("Signal recipient is required");
+    }
     const lower = value.toLowerCase();
     if (lower.startsWith("signal:")) {
         value = value.slice("signal:".length).trim();
@@ -31,44 +32,25 @@ function parseTarget(raw) {
 }
 function buildTargetParams(target, allow) {
     if (target.type === "recipient") {
-        if (!allow.recipient)
+        if (!allow.recipient) {
             return null;
+        }
         return { recipient: [target.recipient] };
     }
     if (target.type === "group") {
-        if (!allow.group)
+        if (!allow.group) {
             return null;
+        }
         return { groupId: target.groupId };
     }
     if (target.type === "username") {
-        if (!allow.username)
+        if (!allow.username) {
             return null;
+        }
         return { username: [target.username] };
     }
     return null;
 }
-function resolveSignalRpcContext(opts, accountInfo) {
-    const hasBaseUrl = Boolean(opts.baseUrl?.trim());
-    const hasAccount = Boolean(opts.account?.trim());
-    const resolvedAccount = accountInfo ||
-        (!hasBaseUrl || !hasAccount
-            ? resolveSignalAccount({
-                cfg: loadConfig(),
-                accountId: opts.accountId,
-            })
-            : undefined);
-    const baseUrl = opts.baseUrl?.trim() || resolvedAccount?.baseUrl;
-    if (!baseUrl) {
-        throw new Error("Signal base URL is required");
-    }
-    const account = opts.account?.trim() || resolvedAccount?.config.account?.trim();
-    return { baseUrl, account };
-}
-async function resolveAttachment(mediaUrl, maxBytes) {
-    const media = await loadWebMedia(mediaUrl, maxBytes);
-    const saved = await saveMediaBuffer(media.buffer, media.contentType ?? undefined, "outbound", maxBytes);
-    return { path: saved.path, contentType: saved.contentType };
-}
 export async function sendMessageSignal(to, text, opts = {}) {
     const cfg = loadConfig();
     const accountInfo = resolveSignalAccount({
@@ -82,8 +64,9 @@ export async function sendMessageSignal(to, text, opts = {}) {
     let textStyles = [];
     const textMode = opts.textMode ?? "markdown";
     const maxBytes = (() => {
-        if (typeof opts.maxBytes === "number")
+        if (typeof opts.maxBytes === "number") {
             return opts.maxBytes;
+        }
         if (typeof accountInfo.config.mediaMaxMb === "number") {
             return accountInfo.config.mediaMaxMb * 1024 * 1024;
         }
@@ -94,7 +77,9 @@ export async function sendMessageSignal(to, text, opts = {}) {
     })();
     let attachments;
     if (opts.mediaUrl?.trim()) {
-        const resolved = await resolveAttachment(opts.mediaUrl.trim(), maxBytes);
+        const resolved = await resolveOutboundAttachmentFromUrl(opts.mediaUrl.trim(), maxBytes, {
+            localRoots: opts.mediaLocalRoots,
+        });
         attachments = [resolved.path];
         const kind = mediaKindFromMime(resolved.contentType ?? undefined);
         if (!message && kind) {
@@ -125,8 +110,9 @@ export async function sendMessageSignal(to, text, opts = {}) {
     if (textStyles.length > 0) {
         params["text-style"] = textStyles.map((style) => `${style.start}:${style.length}:${style.style}`);
     }
-    if (account)
+    if (account) {
         params.account = account;
+    }
     if (attachments && attachments.length > 0) {
         params.attachments = attachments;
     }
@@ -155,13 +141,16 @@ export async function sendTypingSignal(to, opts = {}) {
         recipient: true,
         group: true,
     });
-    if (!targetParams)
+    if (!targetParams) {
         return false;
+    }
     const params = { ...targetParams };
-    if (account)
+    if (account) {
         params.account = account;
-    if (opts.stop)
+    }
+    if (opts.stop) {
         params.stop = true;
+    }
     await signalRpcRequest("sendTyping", params, {
         baseUrl,
         timeoutMs: opts.timeoutMs,
@@ -169,21 +158,24 @@ export async function sendTypingSignal(to, opts = {}) {
     return true;
 }
 export async function sendReadReceiptSignal(to, targetTimestamp, opts = {}) {
-    if (!Number.isFinite(targetTimestamp) || targetTimestamp <= 0)
+    if (!Number.isFinite(targetTimestamp) || targetTimestamp <= 0) {
         return false;
+    }
     const { baseUrl, account } = resolveSignalRpcContext(opts);
     const targetParams = buildTargetParams(parseTarget(to), {
         recipient: true,
     });
-    if (!targetParams)
+    if (!targetParams) {
         return false;
+    }
     const params = {
         ...targetParams,
         targetTimestamp,
         type: opts.type ?? "read",
     };
-    if (account)
+    if (account) {
         params.account = account;
+    }
     await signalRpcRequest("sendReceipt", params, {
         baseUrl,
         timeoutMs: opts.timeoutMs,

package/dist/slack/monitor/allow-list.js

@@ -1,21 +1,18 @@
+import { normalizeHyphenSlug, normalizeStringEntries, normalizeStringEntriesLower, } from "../../shared/string-normalization.js";
 export function normalizeSlackSlug(raw) {
-    const trimmed = raw?.trim().toLowerCase() ?? "";
-    if (!trimmed)
-        return "";
-    const dashed = trimmed.replace(/\s+/g, "-");
-    const cleaned = dashed.replace(/[^a-z0-9#@._+-]+/g, "-");
-    return cleaned.replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "");
+    return normalizeHyphenSlug(raw);
 }
 export function normalizeAllowList(list) {
-    return (list ?? []).map((entry) => String(entry).trim()).filter(Boolean);
+    return normalizeStringEntries(list);
 }
 export function normalizeAllowListLower(list) {
-    return normalizeAllowList(list).map((entry) => entry.toLowerCase());
+    return normalizeStringEntriesLower(list);
 }
 export function resolveSlackAllowListMatch(params) {
     const allowList = params.allowList;
-    if (allowList.length === 0)
+    if (allowList.length === 0) {
         return { allowed: false };
+    }
     if (allowList.includes("*")) {
         return { allowed: true, matchKey: "*", matchSource: "wildcard" };
     }
@@ -31,8 +28,9 @@ export function resolveSlackAllowListMatch(params) {
         { value: slug, source: "slug" },
     ];
     for (const candidate of candidates) {
-        if (!candidate.value)
+        if (!candidate.value) {
             continue;
+        }
         if (allowList.includes(candidate.value)) {
             return {
                 allowed: true,
@@ -48,8 +46,9 @@ export function allowListMatches(params) {
 }
 export function resolveSlackUserAllowed(params) {
     const allowList = normalizeAllowListLower(params.allowList);
-    if (allowList.length === 0)
+    if (allowList.length === 0) {
         return true;
+    }
     return allowListMatches({
         allowList,
         id: params.userId,

package/dist/slack/monitor/commands.js

@@ -1,9 +1,19 @@
+/**
+ * Strip Slack mentions (<@U123>, <@U123|name>) so command detection works on
+ * normalized text. Use in both prepare and debounce gate for consistency.
+ */
+export function stripSlackMentionsForCommandDetection(text) {
+    return (text ?? "")
+        .replace(/<@[^>]+>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
 export function normalizeSlackSlashCommandName(raw) {
     return raw.replace(/^\/+/, "");
 }
 export function resolveSlackSlashCommandConfig(raw) {
-    const normalizedName = normalizeSlackSlashCommandName(raw?.name?.trim() || "clawd");
-    const name = normalizedName || "clawd";
+    const normalizedName = normalizeSlackSlashCommandName(raw?.name?.trim() || "poolbot");
+    const name = normalizedName || "poolbot";
     return {
         enabled: raw?.enabled === true,
         name,
@@ -12,6 +22,7 @@ export function resolveSlackSlashCommandConfig(raw) {
     };
 }
 export function buildSlackSlashCommandMatcher(name) {
-    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const normalized = normalizeSlackSlashCommandName(name);
+    const escaped = normalized.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     return new RegExp(`^/?${escaped}$`);
 }

package/dist/slack/monitor/events/interactions.js

@@ -1,7 +1,7 @@
 import { enqueueSystemEvent } from "../../../infra/system-events.js";
 import { parseSlackModalPrivateMetadata } from "../../modal-metadata.js";
-// Prefix for OpenClaw-generated action IDs to scope our handler
-const POOLBOT_ACTION_PREFIX = "openclaw:";
+// Prefix for Pool Bot-generated action IDs to scope our handler
+const POOLBOT_ACTION_PREFIX = "poolbot:";
 function readOptionValues(options) {
     if (!Array.isArray(options)) {
         return undefined;
@@ -255,7 +255,7 @@ export function registerSlackInteractionEvents(params) {
     if (typeof ctx.app.action !== "function") {
         return;
     }
-    // Handle Block Kit button clicks from OpenClaw-generated messages
+    // Handle Block Kit button clicks from Pool Bot-generated messages
     // Only matches action_ids that start with our prefix to avoid interfering
     // with other Slack integrations or future features
     ctx.app.action(new RegExp(`^${POOLBOT_ACTION_PREFIX}`), async (args) => {
@@ -378,7 +378,7 @@ export function registerSlackInteractionEvents(params) {
     if (typeof ctx.app.view !== "function") {
         return;
     }
-    // Handle OpenClaw modal submissions with callback_ids scoped by our prefix.
+    // Handle Pool Bot modal submissions with callback_ids scoped by our prefix.
     ctx.app.view(new RegExp(`^${POOLBOT_ACTION_PREFIX}`), async ({ ack, body }) => {
         await ack();
         const typedBody = body;