@poolzin/pool-bot 2026.2.20 → 2026.2.22

package/dist/discord/monitor/threading.js

@@ -4,19 +4,53 @@ import { createReplyReferencePlanner } from "../../auto-reply/reply/reply-refere
 import { logVerbose } from "../../globals.js";
 import { buildAgentSessionKey } from "../../routing/resolve-route.js";
 import { truncateUtf16Safe } from "../../utils.js";
-import { resolveDiscordChannelInfo } from "./message-utils.js";
+import { resolveDiscordChannelInfo, resolveDiscordMessageChannelId } from "./message-utils.js";
+// Cache configuration: 5 minute TTL (thread starters rarely change), max 500 entries
+const DISCORD_THREAD_STARTER_CACHE_TTL_MS = 5 * 60 * 1000;
+const DISCORD_THREAD_STARTER_CACHE_MAX = 500;
 const DISCORD_THREAD_STARTER_CACHE = new Map();
 export function __resetDiscordThreadStarterCacheForTest() {
     DISCORD_THREAD_STARTER_CACHE.clear();
 }
+// Get cached entry with TTL check, refresh LRU position on hit
+function getCachedThreadStarter(key, now) {
+    const entry = DISCORD_THREAD_STARTER_CACHE.get(key);
+    if (!entry) {
+        return undefined;
+    }
+    // Check TTL expiry
+    if (now - entry.updatedAt > DISCORD_THREAD_STARTER_CACHE_TTL_MS) {
+        DISCORD_THREAD_STARTER_CACHE.delete(key);
+        return undefined;
+    }
+    // Refresh LRU position by re-inserting (Map maintains insertion order)
+    DISCORD_THREAD_STARTER_CACHE.delete(key);
+    DISCORD_THREAD_STARTER_CACHE.set(key, { ...entry, updatedAt: now });
+    return entry.value;
+}
+// Set cached entry with LRU eviction when max size exceeded
+function setCachedThreadStarter(key, value, now) {
+    // Remove existing entry first (to update LRU position)
+    DISCORD_THREAD_STARTER_CACHE.delete(key);
+    DISCORD_THREAD_STARTER_CACHE.set(key, { value, updatedAt: now });
+    // Evict oldest entries (first in Map) when over max size
+    while (DISCORD_THREAD_STARTER_CACHE.size > DISCORD_THREAD_STARTER_CACHE_MAX) {
+        const iter = DISCORD_THREAD_STARTER_CACHE.keys().next();
+        if (iter.done) {
+            break;
+        }
+        DISCORD_THREAD_STARTER_CACHE.delete(iter.value);
+    }
+}
 function isDiscordThreadType(type) {
     return (type === ChannelType.PublicThread ||
         type === ChannelType.PrivateThread ||
         type === ChannelType.AnnouncementThread);
 }
 export function resolveDiscordThreadChannel(params) {
-    if (!params.isGuildMessage)
+    if (!params.isGuildMessage) {
         return null;
+    }
     const { message, channelInfo } = params;
     const channel = "channel" in message ? message.channel : undefined;
     const isThreadChannel = channel &&
@@ -24,12 +58,21 @@ export function resolveDiscordThreadChannel(params) {
         "isThread" in channel &&
         typeof channel.isThread === "function" &&
         channel.isThread();
-    if (isThreadChannel)
+    if (isThreadChannel) {
         return channel;
-    if (!isDiscordThreadType(channelInfo?.type))
+    }
+    if (!isDiscordThreadType(channelInfo?.type)) {
+        return null;
+    }
+    const messageChannelId = params.messageChannelId ||
+        resolveDiscordMessageChannelId({
+            message,
+        });
+    if (!messageChannelId) {
         return null;
+    }
     return {
-        id: message.channelId,
+        id: messageChannelId,
         name: channelInfo?.name ?? undefined,
         parentId: channelInfo?.parentId ?? undefined,
         parent: undefined,
@@ -39,8 +82,9 @@ export function resolveDiscordThreadChannel(params) {
 export async function resolveDiscordThreadParentInfo(params) {
     const { threadChannel, channelInfo, client } = params;
     const parentId = threadChannel.parentId ?? threadChannel.parent?.id ?? channelInfo?.parentId ?? undefined;
-    if (!parentId)
+    if (!parentId) {
         return {};
+    }
     let parentName = threadChannel.parent?.name;
     const parentInfo = await resolveDiscordChannelInfo(client, parentId);
     parentName = parentName ?? parentInfo?.name;
@@ -49,21 +93,26 @@ export async function resolveDiscordThreadParentInfo(params) {
 }
 export async function resolveDiscordThreadStarter(params) {
     const cacheKey = params.channel.id;
-    const cached = DISCORD_THREAD_STARTER_CACHE.get(cacheKey);
-    if (cached)
+    const now = Date.now();
+    const cached = getCachedThreadStarter(cacheKey, now);
+    if (cached) {
         return cached;
+    }
     try {
         const parentType = params.parentType;
         const isForumParent = parentType === ChannelType.GuildForum || parentType === ChannelType.GuildMedia;
         const messageChannelId = isForumParent ? params.channel.id : params.parentId;
-        if (!messageChannelId)
+        if (!messageChannelId) {
             return null;
+        }
         const starter = (await params.client.rest.get(Routes.channelMessage(messageChannelId, params.channel.id)));
-        if (!starter)
+        if (!starter) {
             return null;
+        }
         const text = starter.content?.trim() ?? starter.embeds?.[0]?.description?.trim() ?? "";
-        if (!text)
+        if (!text) {
             return null;
+        }
         const author = starter.member?.nick ??
             starter.member?.displayName ??
             (starter.author
@@ -77,7 +126,7 @@ export async function resolveDiscordThreadStarter(params) {
             author,
             timestamp: timestamp ?? undefined,
         };
-        DISCORD_THREAD_STARTER_CACHE.set(cacheKey, payload);
+        setCachedThreadStarter(cacheKey, payload, Date.now());
         return payload;
     }
     catch {
@@ -85,13 +134,16 @@ export async function resolveDiscordThreadStarter(params) {
     }
 }
 export function resolveDiscordReplyTarget(opts) {
-    if (opts.replyToMode === "off")
+    if (opts.replyToMode === "off") {
         return undefined;
+    }
     const replyToId = opts.replyToId?.trim();
-    if (!replyToId)
+    if (!replyToId) {
         return undefined;
-    if (opts.replyToMode === "all")
+    }
+    if (opts.replyToMode === "all") {
         return replyToId;
+    }
     return opts.hasReplied ? undefined : replyToId;
 }
 export function sanitizeDiscordThreadName(rawName, fallbackId) {
@@ -107,11 +159,13 @@ export function sanitizeDiscordThreadName(rawName, fallbackId) {
 }
 export function resolveDiscordAutoThreadContext(params) {
     const createdThreadId = String(params.createdThreadId ?? "").trim();
-    if (!createdThreadId)
+    if (!createdThreadId) {
         return null;
+    }
     const messageChannelId = params.messageChannelId.trim();
-    if (!messageChannelId)
+    if (!messageChannelId) {
         return null;
+    }
     const threadSessionKey = buildAgentSessionKey({
         agentId: params.agentId,
         channel: params.channel,
@@ -132,13 +186,21 @@ export function resolveDiscordAutoThreadContext(params) {
     };
 }
 export async function resolveDiscordAutoThreadReplyPlan(params) {
-    const originalReplyTarget = `channel:${params.message.channelId}`;
+    const messageChannelId = (params.messageChannelId ||
+        resolveDiscordMessageChannelId({
+            message: params.message,
+        })).trim();
+    // Prefer the resolved thread channel ID when available so replies stay in-thread.
+    const targetChannelId = params.threadChannel?.id ?? (messageChannelId || "unknown");
+    const originalReplyTarget = `channel:${targetChannelId}`;
     const createdThreadId = await maybeCreateDiscordAutoThread({
         client: params.client,
         message: params.message,
+        messageChannelId: messageChannelId || undefined,
         isGuildMessage: params.isGuildMessage,
         channelConfig: params.channelConfig,
         threadChannel: params.threadChannel,
+        channelType: params.channelType,
         baseText: params.baseText,
         combinedBody: params.combinedBody,
     });
@@ -153,22 +215,39 @@ export async function resolveDiscordAutoThreadReplyPlan(params) {
         ? resolveDiscordAutoThreadContext({
             agentId: params.agentId,
             channel: params.channel,
-            messageChannelId: params.message.channelId,
+            messageChannelId,
             createdThreadId,
         })
         : null;
     return { ...deliveryPlan, createdThreadId, autoThreadContext };
 }
 export async function maybeCreateDiscordAutoThread(params) {
-    if (!params.isGuildMessage)
+    if (!params.isGuildMessage) {
         return undefined;
-    if (!params.channelConfig?.autoThread)
+    }
+    if (!params.channelConfig?.autoThread) {
         return undefined;
-    if (params.threadChannel)
+    }
+    if (params.threadChannel) {
+        return undefined;
+    }
+    // Avoid creating threads in channels that don't support it or are already forums
+    if (params.channelType === ChannelType.GuildForum ||
+        params.channelType === ChannelType.GuildMedia ||
+        params.channelType === ChannelType.GuildVoice ||
+        params.channelType === ChannelType.GuildStageVoice) {
         return undefined;
+    }
+    const messageChannelId = (params.messageChannelId ||
+        resolveDiscordMessageChannelId({
+            message: params.message,
+        })).trim();
+    if (!messageChannelId) {
+        return undefined;
+    }
     try {
         const threadName = sanitizeDiscordThreadName(params.baseText || params.combinedBody || "Thread", params.message.id);
-        const created = (await params.client.rest.post(`${Routes.channelMessage(params.message.channelId, params.message.id)}/threads`, {
+        const created = (await params.client.rest.post(`${Routes.channelMessage(messageChannelId, params.message.id)}/threads`, {
             body: {
                 name: threadName,
                 auto_archive_duration: 60,
@@ -178,7 +257,20 @@ export async function maybeCreateDiscordAutoThread(params) {
         return createdId || undefined;
     }
     catch (err) {
-        logVerbose(`discord: autoThread failed for ${params.message.channelId}/${params.message.id}: ${String(err)}`);
+        logVerbose(`discord: autoThread creation failed for ${messageChannelId}/${params.message.id}: ${String(err)}`);
+        // Race condition: another agent may have already created a thread on this
+        // message. Re-fetch the message to check for an existing thread.
+        try {
+            const msg = (await params.client.rest.get(Routes.channelMessage(messageChannelId, params.message.id)));
+            const existingThreadId = msg?.thread?.id ? String(msg.thread.id) : "";
+            if (existingThreadId) {
+                logVerbose(`discord: autoThread reusing existing thread ${existingThreadId} on ${messageChannelId}/${params.message.id}`);
+                return existingThreadId;
+            }
+        }
+        catch {
+            // If the refetch also fails, fall through to return undefined.
+        }
         return undefined;
     }
 }
@@ -186,6 +278,7 @@ export function resolveDiscordReplyDeliveryPlan(params) {
     const originalReplyTarget = params.replyTarget;
     let deliverTarget = originalReplyTarget;
     let replyTarget = originalReplyTarget;
+    // When a new thread was created, route to the new thread.
     if (params.createdThreadId) {
         deliverTarget = `channel:${params.createdThreadId}`;
         replyTarget = deliverTarget;

package/dist/discord/send.js

@@ -2,6 +2,7 @@ export { createChannelDiscord, deleteChannelDiscord, editChannelDiscord, moveCha
 export { listGuildEmojisDiscord, uploadEmojiDiscord, uploadStickerDiscord, } from "./send.emojis-stickers.js";
 export { addRoleDiscord, banMemberDiscord, createScheduledEventDiscord, fetchChannelInfoDiscord, fetchMemberInfoDiscord, fetchRoleInfoDiscord, fetchVoiceStatusDiscord, kickMemberDiscord, listGuildChannelsDiscord, listScheduledEventsDiscord, removeRoleDiscord, timeoutMemberDiscord, } from "./send.guild.js";
 export { createThreadDiscord, deleteMessageDiscord, editMessageDiscord, fetchMessageDiscord, listPinsDiscord, listThreadsDiscord, pinMessageDiscord, readMessagesDiscord, searchMessagesDiscord, unpinMessageDiscord, } from "./send.messages.js";
-export { sendMessageDiscord, sendPollDiscord, sendStickerDiscord } from "./send.outbound.js";
+export { sendMessageDiscord, sendPollDiscord, sendStickerDiscord, sendVoiceMessageDiscord, } from "./send.outbound.js";
+export { sendDiscordComponentMessage } from "./send.components.js";
 export { fetchChannelPermissionsDiscord, fetchReactionsDiscord, reactMessageDiscord, removeOwnReactionsDiscord, removeReactionDiscord, } from "./send.reactions.js";
 export { DiscordSendError } from "./send.types.js";

package/dist/discord/send.outbound.js

@@ -1,11 +1,20 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { serializePayload } from "@buape/carbon";
 import { ChannelType, Routes } from "discord-api-types/v10";
 import { resolveChunkMode } from "../auto-reply/chunk.js";
 import { loadConfig } from "../config/config.js";
 import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
 import { recordChannelActivity } from "../infra/channel-activity.js";
+import { resolvePreferredPoolbotTmpDir } from "../infra/tmp-poolbot-dir.js";
 import { convertMarkdownTables } from "../markdown/tables.js";
+import { maxBytesForKind } from "../media/constants.js";
+import { extensionForMime } from "../media/mime.js";
+import { loadWebMediaRaw } from "../web/media.js";
 import { resolveDiscordAccount } from "./accounts.js";
-import { buildDiscordSendError, buildDiscordTextChunks, createDiscordClient, normalizeDiscordPollInput, normalizeStickerIds, parseAndResolveRecipient, resolveChannelId, sendDiscordMedia, sendDiscordText, } from "./send.shared.js";
+import { buildDiscordMessagePayload, buildDiscordSendError, buildDiscordTextChunks, createDiscordClient, normalizeDiscordPollInput, normalizeStickerIds, parseAndResolveRecipient, resolveChannelId, resolveDiscordSendComponents, resolveDiscordSendEmbeds, sendDiscordMedia, sendDiscordText, stripUndefinedFields, SUPPRESS_NOTIFICATIONS_FLAG, } from "./send.shared.js";
+import { ensureOggOpus, getVoiceMessageMetadata, sendDiscordVoiceMessage, } from "./voice-message.js";
 /** Discord thread names are capped at 100 characters. */
 const DISCORD_THREAD_NAME_LIMIT = 100;
 /** Derive a thread title from the first non-empty line of the message text. */
@@ -52,16 +61,25 @@ export async function sendMessageDiscord(to, text, opts = {}) {
             chunkMode,
         });
         const starterContent = chunks[0]?.trim() ? chunks[0] : threadName;
-        const starterEmbeds = opts.embeds?.length ? opts.embeds : undefined;
+        const starterComponents = resolveDiscordSendComponents({
+            components: opts.components,
+            text: starterContent,
+            isFirst: true,
+        });
+        const starterEmbeds = resolveDiscordSendEmbeds({ embeds: opts.embeds, isFirst: true });
+        const silentFlags = opts.silent ? 1 << 12 : undefined;
+        const starterPayload = buildDiscordMessagePayload({
+            text: starterContent,
+            components: starterComponents,
+            embeds: starterEmbeds,
+            flags: silentFlags,
+        });
         let threadRes;
         try {
             threadRes = (await request(() => rest.post(Routes.threads(channelId), {
                 body: {
                     name: threadName,
-                    message: {
-                        content: starterContent,
-                        ...(starterEmbeds ? { embeds: starterEmbeds } : {}),
-                    },
+                    message: stripUndefinedFields(serializePayload(starterPayload)),
                 },
             }), "forum-thread"));
         }
@@ -80,14 +98,14 @@ export async function sendMessageDiscord(to, text, opts = {}) {
         try {
             if (opts.mediaUrl) {
                 const [mediaCaption, ...afterMediaChunks] = remainingChunks;
-                await sendDiscordMedia(rest, threadId, mediaCaption ?? "", opts.mediaUrl, undefined, request, accountInfo.config.maxLinesPerMessage, undefined, chunkMode);
+                await sendDiscordMedia(rest, threadId, mediaCaption ?? "", opts.mediaUrl, opts.mediaLocalRoots, undefined, request, accountInfo.config.maxLinesPerMessage, undefined, undefined, chunkMode, opts.silent);
                 for (const chunk of afterMediaChunks) {
-                    await sendDiscordText(rest, threadId, chunk, undefined, request, accountInfo.config.maxLinesPerMessage, undefined, chunkMode);
+                    await sendDiscordText(rest, threadId, chunk, undefined, request, accountInfo.config.maxLinesPerMessage, undefined, undefined, chunkMode, opts.silent);
                 }
             }
             else {
                 for (const chunk of remainingChunks) {
-                    await sendDiscordText(rest, threadId, chunk, undefined, request, accountInfo.config.maxLinesPerMessage, undefined, chunkMode);
+                    await sendDiscordText(rest, threadId, chunk, undefined, request, accountInfo.config.maxLinesPerMessage, undefined, undefined, chunkMode, opts.silent);
                 }
             }
         }
@@ -112,10 +130,10 @@ export async function sendMessageDiscord(to, text, opts = {}) {
     let result;
     try {
         if (opts.mediaUrl) {
-            result = await sendDiscordMedia(rest, channelId, textWithTables, opts.mediaUrl, opts.replyTo, request, accountInfo.config.maxLinesPerMessage, opts.embeds, chunkMode);
+            result = await sendDiscordMedia(rest, channelId, textWithTables, opts.mediaUrl, opts.mediaLocalRoots, opts.replyTo, request, accountInfo.config.maxLinesPerMessage, opts.components, opts.embeds, chunkMode, opts.silent);
         }
         else {
-            result = await sendDiscordText(rest, channelId, textWithTables, opts.replyTo, request, accountInfo.config.maxLinesPerMessage, opts.embeds, chunkMode);
+            result = await sendDiscordText(rest, channelId, textWithTables, opts.replyTo, request, accountInfo.config.maxLinesPerMessage, opts.components, opts.embeds, chunkMode, opts.silent);
         }
     }
     catch (err) {
@@ -160,11 +178,16 @@ export async function sendPollDiscord(to, poll, opts = {}) {
     const recipient = await parseAndResolveRecipient(to, opts.accountId);
     const { channelId } = await resolveChannelId(rest, recipient, request);
     const content = opts.content?.trim();
+    if (poll.durationSeconds !== undefined) {
+        throw new Error("Discord polls do not support durationSeconds; use durationHours");
+    }
     const payload = normalizeDiscordPollInput(poll);
+    const flags = opts.silent ? SUPPRESS_NOTIFICATIONS_FLAG : undefined;
     const res = (await request(() => rest.post(Routes.channelMessages(channelId), {
         body: {
             content: content || undefined,
             poll: payload,
+            ...(flags ? { flags } : {}),
         },
     }), "poll"));
     return {
@@ -172,3 +195,93 @@ export async function sendPollDiscord(to, poll, opts = {}) {
         channelId: String(res.channel_id ?? channelId),
     };
 }
+async function materializeVoiceMessageInput(mediaUrl) {
+    // Security: reuse the standard media loader so we apply SSRF guards + allowed-local-root checks.
+    // Then write to a private temp file so ffmpeg/ffprobe never sees the original URL/path string.
+    const media = await loadWebMediaRaw(mediaUrl, maxBytesForKind("audio"));
+    const extFromName = media.fileName ? path.extname(media.fileName) : "";
+    const extFromMime = media.contentType ? extensionForMime(media.contentType) : "";
+    const ext = extFromName || extFromMime || ".bin";
+    const tempDir = resolvePreferredPoolbotTmpDir();
+    const filePath = path.join(tempDir, `voice-src-${crypto.randomUUID()}${ext}`);
+    await fs.writeFile(filePath, media.buffer, { mode: 0o600 });
+    return { filePath };
+}
+/**
+ * Send a voice message to Discord.
+ *
+ * Voice messages are a special Discord feature that displays audio with a waveform
+ * visualization. They require OGG/Opus format and cannot include text content.
+ *
+ * @param to - Recipient (user ID for DM or channel ID)
+ * @param audioPath - Path to local audio file (will be converted to OGG/Opus if needed)
+ * @param opts - Send options
+ */
+export async function sendVoiceMessageDiscord(to, audioPath, opts = {}) {
+    const { filePath: localInputPath } = await materializeVoiceMessageInput(audioPath);
+    let oggPath = null;
+    let oggCleanup = false;
+    let token;
+    let rest;
+    let channelId;
+    try {
+        const cfg = loadConfig();
+        const accountInfo = resolveDiscordAccount({
+            cfg,
+            accountId: opts.accountId,
+        });
+        const client = createDiscordClient(opts, cfg);
+        token = client.token;
+        rest = client.rest;
+        const request = client.request;
+        const recipient = await parseAndResolveRecipient(to, opts.accountId);
+        channelId = (await resolveChannelId(rest, recipient, request)).channelId;
+        // Convert to OGG/Opus if needed
+        const ogg = await ensureOggOpus(localInputPath);
+        oggPath = ogg.path;
+        oggCleanup = ogg.cleanup;
+        // Get voice message metadata (duration and waveform)
+        const metadata = await getVoiceMessageMetadata(oggPath);
+        // Read the audio file
+        const audioBuffer = await fs.readFile(oggPath);
+        // Send the voice message
+        const result = await sendDiscordVoiceMessage(rest, channelId, audioBuffer, metadata, opts.replyTo, request, opts.silent);
+        recordChannelActivity({
+            channel: "discord",
+            accountId: accountInfo.accountId,
+            direction: "outbound",
+        });
+        return {
+            messageId: result.id ? String(result.id) : "unknown",
+            channelId: String(result.channel_id ?? channelId),
+        };
+    }
+    catch (err) {
+        if (channelId && rest && token) {
+            throw await buildDiscordSendError(err, {
+                channelId,
+                rest,
+                token,
+                hasMedia: true,
+            });
+        }
+        throw err;
+    }
+    finally {
+        // Clean up temporary OGG file if we created one
+        if (oggCleanup && oggPath) {
+            try {
+                await fs.unlink(oggPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        try {
+            await fs.unlink(localInputPath);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}