@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/discord/monitor/message-utils.js

@@ -7,11 +7,28 @@ const DISCORD_CHANNEL_INFO_CACHE = new Map();
 export function __resetDiscordChannelInfoCacheForTest() {
     DISCORD_CHANNEL_INFO_CACHE.clear();
 }
+function normalizeDiscordChannelId(value) {
+    if (typeof value === "string") {
+        return value.trim();
+    }
+    if (typeof value === "number" || typeof value === "bigint") {
+        return String(value).trim();
+    }
+    return "";
+}
+export function resolveDiscordMessageChannelId(params) {
+    const message = params.message;
+    return (normalizeDiscordChannelId(message.channelId) ||
+        normalizeDiscordChannelId(message.channel_id) ||
+        normalizeDiscordChannelId(message.rawData?.channel_id) ||
+        normalizeDiscordChannelId(params.eventChannelId));
+}
 export async function resolveDiscordChannelInfo(client, channelId) {
     const cached = DISCORD_CHANNEL_INFO_CACHE.get(channelId);
     if (cached) {
-        if (cached.expiresAt > Date.now())
+        if (cached.expiresAt > Date.now()) {
             return cached.value;
+        }
         DISCORD_CHANNEL_INFO_CACHE.delete(channelId);
     }
     try {
@@ -51,17 +68,47 @@ export async function resolveDiscordChannelInfo(client, channelId) {
 }
 export async function resolveMediaList(message, maxBytes) {
     const attachments = message.attachments ?? [];
-    if (attachments.length === 0)
+    if (attachments.length === 0) {
+        return [];
+    }
+    const out = [];
+    await appendResolvedMediaFromAttachments({
+        attachments,
+        maxBytes,
+        out,
+        errorPrefix: "discord: failed to download attachment",
+    });
+    return out;
+}
+export async function resolveForwardedMediaList(message, maxBytes) {
+    const snapshots = resolveDiscordMessageSnapshots(message);
+    if (snapshots.length === 0) {
         return [];
+    }
     const out = [];
+    for (const snapshot of snapshots) {
+        await appendResolvedMediaFromAttachments({
+            attachments: snapshot.message?.attachments,
+            maxBytes,
+            out,
+            errorPrefix: "discord: failed to download forwarded attachment",
+        });
+    }
+    return out;
+}
+async function appendResolvedMediaFromAttachments(params) {
+    const attachments = params.attachments;
+    if (!attachments || attachments.length === 0) {
+        return;
+    }
     for (const attachment of attachments) {
         try {
             const fetched = await fetchRemoteMedia({
                 url: attachment.url,
                 filePathHint: attachment.filename ?? attachment.url,
             });
-            const saved = await saveMediaBuffer(fetched.buffer, fetched.contentType ?? attachment.content_type, "inbound", maxBytes);
-            out.push({
+            const saved = await saveMediaBuffer(fetched.buffer, fetched.contentType ?? attachment.content_type, "inbound", params.maxBytes);
+            params.out.push({
                 path: saved.path,
                 contentType: saved.contentType,
                 placeholder: inferPlaceholder(attachment),
@@ -69,33 +116,38 @@ export async function resolveMediaList(message, maxBytes) {
         }
         catch (err) {
             const id = attachment.id ?? attachment.url;
-            logVerbose(`discord: failed to download attachment ${id}: ${String(err)}`);
+            logVerbose(`${params.errorPrefix} ${id}: ${String(err)}`);
         }
     }
-    return out;
 }
 function inferPlaceholder(attachment) {
     const mime = attachment.content_type ?? "";
-    if (mime.startsWith("image/"))
+    if (mime.startsWith("image/")) {
         return "<media:image>";
-    if (mime.startsWith("video/"))
+    }
+    if (mime.startsWith("video/")) {
         return "<media:video>";
-    if (mime.startsWith("audio/"))
+    }
+    if (mime.startsWith("audio/")) {
         return "<media:audio>";
+    }
     return "<media:document>";
 }
 function isImageAttachment(attachment) {
     const mime = attachment.content_type ?? "";
-    if (mime.startsWith("image/"))
+    if (mime.startsWith("image/")) {
         return true;
+    }
     const name = attachment.filename?.toLowerCase() ?? "";
-    if (!name)
+    if (!name) {
         return false;
+    }
     return /\.(avif|bmp|gif|heic|heif|jpe?g|png|tiff?|webp)$/.test(name);
 }
 function buildDiscordAttachmentPlaceholder(attachments) {
-    if (!attachments || attachments.length === 0)
+    if (!attachments || attachments.length === 0) {
         return "";
+    }
     const count = attachments.length;
     const allImages = attachments.every(isImageAttachment);
     const label = allImages ? "image" : "file";
@@ -109,27 +161,33 @@ export function resolveDiscordMessageText(message, options) {
         message.embeds?.[0]?.description ||
         options?.fallbackText?.trim() ||
         "";
-    if (!options?.includeForwarded)
+    if (!options?.includeForwarded) {
         return baseText;
+    }
     const forwardedText = resolveDiscordForwardedMessagesText(message);
-    if (!forwardedText)
+    if (!forwardedText) {
         return baseText;
-    if (!baseText)
+    }
+    if (!baseText) {
         return forwardedText;
+    }
     return `${baseText}\n${forwardedText}`;
 }
 function resolveDiscordForwardedMessagesText(message) {
     const snapshots = resolveDiscordMessageSnapshots(message);
-    if (snapshots.length === 0)
+    if (snapshots.length === 0) {
         return "";
+    }
     const forwardedBlocks = snapshots
         .map((snapshot) => {
         const snapshotMessage = snapshot.message;
-        if (!snapshotMessage)
+        if (!snapshotMessage) {
             return null;
+        }
         const text = resolveDiscordSnapshotMessageText(snapshotMessage);
-        if (!text)
+        if (!text) {
             return null;
+        }
         const authorLabel = formatDiscordSnapshotAuthor(snapshotMessage.author);
         const heading = authorLabel
             ? `[Forwarded message from ${authorLabel}]`
@@ -137,8 +195,9 @@ function resolveDiscordForwardedMessagesText(message) {
         return `${heading}\n${text}`;
     })
         .filter((entry) => Boolean(entry));
-    if (forwardedBlocks.length === 0)
+    if (forwardedBlocks.length === 0) {
         return "";
+    }
     return forwardedBlocks.join("\n\n");
 }
 function resolveDiscordMessageSnapshots(message) {
@@ -146,8 +205,9 @@ function resolveDiscordMessageSnapshots(message) {
     const snapshots = rawData?.message_snapshots ??
         message.message_snapshots ??
         message.messageSnapshots;
-    if (!Array.isArray(snapshots))
+    if (!Array.isArray(snapshots)) {
         return [];
+    }
     return snapshots.filter((entry) => Boolean(entry) && typeof entry === "object");
 }
 function resolveDiscordSnapshotMessageText(snapshot) {
@@ -158,8 +218,9 @@ function resolveDiscordSnapshotMessageText(snapshot) {
     return content || attachmentText || embedText || "";
 }
 function formatDiscordSnapshotAuthor(author) {
-    if (!author)
+    if (!author) {
         return undefined;
+    }
     const globalName = author.global_name ?? undefined;
     const username = author.username ?? undefined;
     const name = author.name ?? undefined;
@@ -168,10 +229,12 @@ function formatDiscordSnapshotAuthor(author) {
     if (username && discriminator && discriminator !== "0") {
         return `@${username}#${discriminator}`;
     }
-    if (base)
+    if (base) {
         return `@${base}`;
-    if (author.id)
+    }
+    if (author.id) {
         return `@${author.id}`;
+    }
     return undefined;
 }
 export function buildDiscordMediaPayload(mediaList) {

package/dist/discord/monitor/native-command.js

@@ -3,25 +3,28 @@ import { ApplicationCommandOptionType, ButtonStyle } from "discord-api-types/v10
 import { resolveHumanDelayConfig } from "../../agents/identity.js";
 import { resolveChunkMode, resolveTextChunkLimit } from "../../auto-reply/chunk.js";
 import { buildCommandTextFromArgs, findCommandByNativeName, listChatCommands, parseCommandArgs, resolveCommandArgChoices, resolveCommandArgMenu, serializeCommandArgs, } from "../../auto-reply/commands-registry.js";
-import { dispatchReplyWithDispatcher } from "../../auto-reply/reply/provider-dispatcher.js";
 import { finalizeInboundContext } from "../../auto-reply/reply/inbound-context.js";
+import { dispatchReplyWithDispatcher } from "../../auto-reply/reply/provider-dispatcher.js";
+import { resolveCommandAuthorizedFromAuthorizers } from "../../channels/command-gating.js";
+import { createReplyPrefixOptions } from "../../channels/reply-prefix.js";
+import { getAgentScopedMediaLocalRoots } from "../../media/local-roots.js";
 import { buildPairingReply } from "../../pairing/pairing-messages.js";
 import { readChannelAllowFromStore, upsertChannelPairingRequest, } from "../../pairing/pairing-store.js";
 import { resolveAgentRoute } from "../../routing/resolve-route.js";
+import { buildUntrustedChannelMetadata } from "../../security/channel-metadata.js";
+import { chunkItems } from "../../utils/chunk-items.js";
 import { loadWebMedia } from "../../web/media.js";
 import { chunkDiscordTextWithMode } from "../chunk.js";
-import { resolveCommandAuthorizedFromAuthorizers } from "../../channels/command-gating.js";
-import { createReplyPrefixContext } from "../../channels/reply-prefix.js";
-import { buildUntrustedChannelMetadata } from "../../security/channel-metadata.js";
-import { allowListMatches, isDiscordGroupAllowedByPolicy, normalizeDiscordAllowList, normalizeDiscordSlug, resolveDiscordChannelConfigWithFallback, resolveDiscordGuildEntry, resolveDiscordOwnerAllowFrom, resolveDiscordUserAllowed, } from "./allow-list.js";
-import { resolveDiscordSenderIdentity } from "./sender-identity.js";
+import { allowListMatches, isDiscordGroupAllowedByPolicy, normalizeDiscordAllowList, normalizeDiscordSlug, resolveDiscordChannelConfigWithFallback, resolveDiscordGuildEntry, resolveDiscordMemberAccessState, resolveDiscordOwnerAllowFrom, } from "./allow-list.js";
 import { resolveDiscordChannelInfo } from "./message-utils.js";
+import { resolveDiscordSenderIdentity } from "./sender-identity.js";
 import { resolveDiscordThreadParentInfo } from "./threading.js";
 function buildDiscordCommandOptions(params) {
     const { command, cfg } = params;
     const args = command.args;
-    if (!args || args.length === 0)
+    if (!args || args.length === 0) {
         return undefined;
+    }
     return args.map((arg) => {
         const required = arg.required ?? false;
         if (arg.type === "number") {
@@ -70,8 +73,9 @@ function buildDiscordCommandOptions(params) {
     });
 }
 function readDiscordCommandArgs(interaction, definitions) {
-    if (!definitions || definitions.length === 0)
+    if (!definitions || definitions.length === 0) {
         return undefined;
+    }
     const values = {};
     for (const definition of definitions) {
         let value;
@@ -90,15 +94,6 @@ function readDiscordCommandArgs(interaction, definitions) {
     }
     return Object.keys(values).length > 0 ? { values } : undefined;
 }
-function chunkItems(items, size) {
-    if (size <= 0)
-        return [items];
-    const rows = [];
-    for (let i = 0; i < items.length; i += size) {
-        rows.push(items.slice(i, i + size));
-    }
-    return rows;
-}
 const DISCORD_COMMAND_ARG_CUSTOM_ID_KEY = "cmdarg";
 function createCommandArgsWithValue(params) {
     const values = { [params.argName]: params.value };
@@ -116,15 +111,19 @@ function decodeDiscordCommandArgValue(value) {
     }
 }
 function isDiscordUnknownInteraction(error) {
-    if (!error || typeof error !== "object")
+    if (!error || typeof error !== "object") {
         return false;
+    }
     const err = error;
-    if (err.discordCode === 10062 || err.rawBody?.code === 10062)
+    if (err.discordCode === 10062 || err.rawBody?.code === 10062) {
         return true;
-    if (err.status === 404 && /Unknown interaction/i.test(err.message ?? ""))
+    }
+    if (err.status === 404 && /Unknown interaction/i.test(err.message ?? "")) {
         return true;
-    if (/Unknown interaction/i.test(err.rawBody?.message ?? ""))
+    }
+    if (/Unknown interaction/i.test(err.rawBody?.message ?? "")) {
         return true;
+    }
     return false;
 }
 async function safeDiscordInteractionCall(label, fn) {
@@ -148,15 +147,17 @@ function buildDiscordCommandArgCustomId(params) {
     ].join(";");
 }
 function parseDiscordCommandArgData(data) {
-    if (!data || typeof data !== "object")
+    if (!data || typeof data !== "object") {
         return null;
+    }
     const coerce = (value) => typeof value === "string" || typeof value === "number" ? String(value) : "";
     const rawCommand = coerce(data.command);
     const rawArg = coerce(data.arg);
     const rawValue = coerce(data.value);
     const rawUser = coerce(data.user);
-    if (!rawCommand || !rawArg || !rawValue || !rawUser)
+    if (!rawCommand || !rawArg || !rawValue || !rawUser) {
         return null;
+    }
     return {
         command: decodeDiscordCommandArgValue(rawCommand),
         arg: decodeDiscordCommandArgValue(rawArg),
@@ -190,8 +191,9 @@ async function handleDiscordCommandArgInteraction(interaction, data, ctx) {
         content: `✅ Selected ${parsed.value}.`,
         components: [],
     }));
-    if (!updated)
+    if (!updated) {
         return;
+    }
     const commandArgs = createCommandArgsWithValue({
         argName: parsed.arg,
         value: parsed.value,
@@ -357,8 +359,9 @@ async function dispatchDiscordCommandInteraction(params) {
     };
     const useAccessGroups = cfg.commands?.useAccessGroups !== false;
     const user = interaction.user;
-    if (!user)
+    if (!user) {
         return;
+    }
     const sender = resolveDiscordSenderIdentity({ author: user, pluralkitInfo: null });
     const channel = interaction.channel;
     const channelType = channel?.type;
@@ -370,11 +373,10 @@ async function dispatchDiscordCommandInteraction(params) {
     const channelName = channel && "name" in channel ? channel.name : undefined;
     const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
     const rawChannelId = channel?.id ?? "";
-    const ownerAllowList = normalizeDiscordAllowList(discordConfig?.dm?.allowFrom ?? [], [
-        "discord:",
-        "user:",
-        "pk:",
-    ]);
+    const memberRoleIds = Array.isArray(interaction.rawData.member?.roles)
+        ? interaction.rawData.member.roles.map((roleId) => String(roleId))
+        : [];
+    const ownerAllowList = normalizeDiscordAllowList(discordConfig?.allowFrom ?? discordConfig?.dm?.allowFrom ?? [], ["discord:", "user:", "pk:"]);
     const ownerOk = ownerAllowList && user
         ? allowListMatches(ownerAllowList, {
             id: sender.id,
@@ -441,7 +443,7 @@ async function dispatchDiscordCommandInteraction(params) {
         }
     }
     const dmEnabled = discordConfig?.dm?.enabled ?? true;
-    const dmPolicy = discordConfig?.dm?.policy ?? "pairing";
+    const dmPolicy = discordConfig?.dmPolicy ?? discordConfig?.dm?.policy ?? "pairing";
     let commandAuthorized = true;
     if (isDirectMessage) {
         if (!dmEnabled || dmPolicy === "disabled") {
@@ -450,7 +452,10 @@ async function dispatchDiscordCommandInteraction(params) {
         }
         if (dmPolicy !== "open") {
             const storeAllowFrom = await readChannelAllowFromStore("discord").catch(() => []);
-            const effectiveAllowFrom = [...(discordConfig?.dm?.allowFrom ?? []), ...storeAllowFrom];
+            const effectiveAllowFrom = [
+                ...(discordConfig?.allowFrom ?? discordConfig?.dm?.allowFrom ?? []),
+                ...storeAllowFrom,
+            ];
             const allowList = normalizeDiscordAllowList(effectiveAllowFrom, ["discord:", "user:", "pk:"]);
             const permitted = allowList
                 ? allowListMatches(allowList, {
@@ -467,7 +472,7 @@ async function dispatchDiscordCommandInteraction(params) {
                         id: user.id,
                         meta: {
                             tag: sender.tag,
-                            name: sender.name ?? undefined,
+                            name: sender.name,
                         },
                     });
                     if (created) {
@@ -487,22 +492,18 @@ async function dispatchDiscordCommandInteraction(params) {
         }
     }
     if (!isDirectMessage) {
-        const channelUsers = channelConfig?.users ?? guildInfo?.users;
-        const hasUserAllowlist = Array.isArray(channelUsers) && channelUsers.length > 0;
-        const userOk = hasUserAllowlist
-            ? resolveDiscordUserAllowed({
-                allowList: channelUsers,
-                userId: sender.id,
-                userName: sender.name,
-                userTag: sender.tag,
-            })
-            : false;
+        const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
+            channelConfig,
+            guildInfo,
+            memberRoleIds,
+            sender,
+        });
         const authorizers = useAccessGroups
             ? [
                 { configured: ownerAllowList != null, allowed: ownerOk },
-                { configured: hasUserAllowlist, allowed: userOk },
+                { configured: hasAccessRestrictions, allowed: memberAllowed },
             ]
-            : [{ configured: hasUserAllowlist, allowed: userOk }];
+            : [{ configured: hasAccessRestrictions, allowed: memberAllowed }];
         commandAuthorized = resolveCommandAuthorizedFromAuthorizers({
             useAccessGroups,
             authorizers,
@@ -555,8 +556,9 @@ async function dispatchDiscordCommandInteraction(params) {
         channel: "discord",
         accountId,
         guildId: interaction.guild?.id ?? undefined,
+        memberRoleIds,
         peer: {
-            kind: isDirectMessage ? "dm" : isGroupDm ? "group" : "channel",
+            kind: isDirectMessage ? "direct" : isGroupDm ? "group" : "channel",
             id: isDirectMessage ? user.id : channelId,
         },
         parentPeer: threadParentId ? { kind: "channel", id: threadParentId } : undefined,
@@ -602,6 +604,7 @@ async function dispatchDiscordCommandInteraction(params) {
                 return untrustedChannelMetadata ? [untrustedChannelMetadata] : undefined;
             })()
             : undefined,
+        OwnerAllowFrom: ownerAllowFrom,
         SenderName: user.globalName ?? user.username,
         SenderId: user.id,
         SenderUsername: user.username,
@@ -613,22 +616,32 @@ async function dispatchDiscordCommandInteraction(params) {
         Timestamp: Date.now(),
         CommandAuthorized: commandAuthorized,
         CommandSource: "native",
-        OwnerAllowFrom: ownerAllowFrom,
+        // Native slash contexts use To=slash:<user> for interaction routing.
+        // For follow-up delivery (for example subagent completion announces),
+        // preserve the real Discord target separately.
+        OriginatingChannel: "discord",
+        OriginatingTo: isDirectMessage ? `user:${user.id}` : `channel:${channelId}`,
+    });
+    const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+        cfg,
+        agentId: route.agentId,
+        channel: "discord",
+        accountId: route.accountId,
     });
-    const prefixContext = createReplyPrefixContext({ cfg, agentId: route.agentId });
+    const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId);
     let didReply = false;
     await dispatchReplyWithDispatcher({
         ctx: ctxPayload,
         cfg,
         dispatcherOptions: {
-            responsePrefix: prefixContext.responsePrefix,
-            responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+            ...prefixOptions,
             humanDelay: resolveHumanDelayConfig(cfg, route.agentId),
             deliver: async (payload) => {
                 try {
                     await deliverDiscordInteractionReply({
                         interaction,
                         payload,
+                        mediaLocalRoots,
                         textLimit: resolveTextChunkLimit(cfg, "discord", accountId, {
                             fallbackLimit: 2000,
                         }),
@@ -655,7 +668,7 @@ async function dispatchDiscordCommandInteraction(params) {
             disableBlockStreaming: typeof discordConfig?.blockStreaming === "boolean"
                 ? !discordConfig.blockStreaming
                 : undefined,
-            onModelSelected: prefixContext.onModelSelected,
+            onModelSelected,
         },
     });
 }
@@ -689,7 +702,9 @@ async function deliverDiscordInteractionReply(params) {
     };
     if (mediaList.length > 0) {
         const media = await Promise.all(mediaList.map(async (url) => {
-            const loaded = await loadWebMedia(url);
+            const loaded = await loadWebMedia(url, {
+                localRoots: params.mediaLocalRoots,
+            });
             return {
                 name: loaded.fileName ?? "upload",
                 data: loaded.buffer,
@@ -700,29 +715,34 @@ async function deliverDiscordInteractionReply(params) {
             maxLines: maxLinesPerMessage,
             chunkMode,
         });
-        if (!chunks.length && text)
+        if (!chunks.length && text) {
             chunks.push(text);
+        }
         const caption = chunks[0] ?? "";
         await sendMessage(caption, media);
         for (const chunk of chunks.slice(1)) {
-            if (!chunk.trim())
+            if (!chunk.trim()) {
                 continue;
+            }
             await interaction.followUp({ content: chunk });
         }
         return;
     }
-    if (!text.trim())
+    if (!text.trim()) {
         return;
+    }
     const chunks = chunkDiscordTextWithMode(text, {
         maxChars: textLimit,
         maxLines: maxLinesPerMessage,
         chunkMode,
     });
-    if (!chunks.length && text)
+    if (!chunks.length && text) {
         chunks.push(text);
+    }
     for (const chunk of chunks) {
-        if (!chunk.trim())
+        if (!chunk.trim()) {
             continue;
+        }
         await sendMessage(chunk);
     }
 }