pi-discord-bot 0.1.1

package/dist/discord-context.js

@@ -0,0 +1,190 @@
+import { chunkText, formatWorkingText, sendOrEditAnchor } from "./discord-ui.js";
+import { createGuildToolApi } from "./discord-guild-tools.js";
+export async function createDiscordContext(params) {
+    const { client, store, event, pendingSlashInteractions, getConversationKeyFromIds, requestApproval } = params;
+    const channel = await client.channels.fetch(event.channelId);
+    if (!channel?.isTextBased())
+        throw new Error(`Channel ${event.channelId} is not text-based`);
+    const slashInteraction = event.source === "slash" ? pendingSlashInteractions.get(event.messageId) ?? null : null;
+    const channels = [...client.channels.cache.values()]
+        .filter((c) => c.isTextBased())
+        .map((c) => ({ id: c.id, name: "name" in c ? (c.name ?? c.id) : c.id }));
+    const users = [...client.users.cache.values()].map((u) => ({ id: u.id, userName: u.username, displayName: u.displayName ?? u.username }));
+    let replyMessageId = null;
+    let currentText = "";
+    let working = true;
+    let detailThreadId = null;
+    let typingInterval = null;
+    const sendable = channel;
+    const fetchAnchorMessage = async () => {
+        if (!replyMessageId)
+            return null;
+        if (slashInteraction) {
+            try {
+                return await slashInteraction.fetchReply();
+            }
+            catch {
+                return null;
+            }
+        }
+        try {
+            return await sendable.messages.fetch(replyMessageId);
+        }
+        catch {
+            return null;
+        }
+    };
+    const sourceMessage = event.source === "message" ? await sendable.messages.fetch(event.messageId).catch(() => null) : null;
+    const syncReaction = async (emoji, enabled) => {
+        if (!sourceMessage)
+            return;
+        try {
+            const existing = sourceMessage.reactions.cache.find((reaction) => reaction.emoji?.name === emoji);
+            if (enabled) {
+                if (!existing)
+                    await sourceMessage.react(emoji);
+            }
+            else if (existing) {
+                await existing.users.remove(client.user?.id);
+            }
+        }
+        catch { }
+    };
+    const sendOrEdit = async (text, shouldLog = true) => {
+        currentText = text;
+        const display = formatWorkingText(text, working);
+        const anchor = await sendOrEditAnchor({ slashInteraction, sendable, replyMessageId, text: display });
+        replyMessageId = anchor.replyMessageId;
+        if (shouldLog && replyMessageId) {
+            const key = getConversationKeyFromIds(event.guildId, event.channelId, event.threadId, event.userId);
+            const entry = {
+                date: new Date().toISOString(),
+                messageId: replyMessageId,
+                channelId: event.channelId,
+                guildId: event.guildId,
+                threadId: event.threadId,
+                authorId: client.user?.id,
+                authorName: client.user?.username,
+                text,
+                isBot: true,
+            };
+            store.appendLog(key, entry);
+        }
+    };
+    const getDetailSendable = async () => {
+        if (channel.isDMBased())
+            return null;
+        if (channel.isThread())
+            return sendable;
+        if (detailThreadId) {
+            const existing = await client.channels.fetch(detailThreadId).catch(() => null);
+            if (existing?.isTextBased())
+                return existing;
+        }
+        const base = await fetchAnchorMessage();
+        if (base && typeof base.startThread === "function") {
+            const thread = await base.startThread({ name: `Details · ${event.userName}`.slice(0, 100), autoArchiveDuration: 1440 }).catch(() => null);
+            if (thread) {
+                detailThreadId = thread.id;
+                return thread;
+            }
+        }
+        return sendable;
+    };
+    const guildApi = createGuildToolApi({ client, event, channel, sendable, fetchAnchorMessage });
+    return {
+        message: event,
+        channels,
+        users,
+        respond: async (text, shouldLog = true) => sendOrEdit(currentText ? `${currentText}\n${text}` : text, shouldLog),
+        replaceMessage: async (text) => {
+            const parts = chunkText(text);
+            await sendOrEdit(parts[0] ?? "", false);
+            for (const part of parts.slice(1))
+                await sendable.send(part);
+        },
+        respondInThread: async (text) => {
+            if (channel.isDMBased())
+                return;
+            const detailSendable = await getDetailSendable();
+            if (!detailSendable)
+                return;
+            for (const part of chunkText(text))
+                await detailSendable.send(part);
+        },
+        setTyping: async (isTyping) => {
+            if (typingInterval) {
+                clearInterval(typingInterval);
+                typingInterval = null;
+            }
+            if (!isTyping)
+                return;
+            if (slashInteraction) {
+                if (!replyMessageId) {
+                    const response = await slashInteraction.editReply("Thinking...");
+                    replyMessageId = response.id;
+                    currentText = "Thinking...";
+                }
+                return;
+            }
+            if (typeof sendable.sendTyping === "function") {
+                await sendable.sendTyping();
+                typingInterval = setInterval(() => {
+                    void sendable.sendTyping().catch(() => { });
+                }, 7000);
+            }
+        },
+        uploadFile: async (filePath, title) => {
+            if (channel.isDMBased()) {
+                await sendable.send({ files: [{ attachment: filePath, name: title }] });
+                return;
+            }
+            const base = await fetchAnchorMessage();
+            if (base && typeof base.reply === "function") {
+                await base.reply({ files: [{ attachment: filePath, name: title }] });
+                return;
+            }
+            if (slashInteraction) {
+                const response = await slashInteraction.editReply(currentText || "Working...");
+                replyMessageId = response.id;
+                if (typeof response.reply === "function") {
+                    await response.reply({ files: [{ attachment: filePath, name: title }] });
+                    return;
+                }
+            }
+            await sendable.send({ files: [{ attachment: filePath, name: title }] });
+        },
+        setWorking: async (isWorking) => {
+            working = isWorking;
+            await syncReaction("🤔", isWorking);
+            if (!isWorking)
+                await syncReaction("🧑‍💻", false);
+            if (!replyMessageId)
+                return;
+            const anchor = await sendOrEditAnchor({ slashInteraction, sendable, replyMessageId, text: formatWorkingText(currentText, working) });
+            replyMessageId = anchor.replyMessageId;
+        },
+        setToolActive: async (active) => {
+            await syncReaction("🧑‍💻", active);
+        },
+        deleteMessage: async () => {
+            if (typingInterval) {
+                clearInterval(typingInterval);
+                typingInterval = null;
+            }
+            if (!replyMessageId)
+                return;
+            if (slashInteraction) {
+                await slashInteraction.deleteReply();
+                pendingSlashInteractions.delete(event.messageId);
+                replyMessageId = null;
+                return;
+            }
+            const msg = await sendable.messages.fetch(replyMessageId);
+            await msg.delete();
+            replyMessageId = null;
+        },
+        confirmAction: async (approvalParams) => requestApproval(event, approvalParams),
+        ...guildApi,
+    };
+}

package/dist/discord-guild-tools.js

@@ -0,0 +1,142 @@
+import { ChannelType, PermissionFlagsBits } from "discord.js";
+export function createGuildToolApi(params) {
+    const { client, event, channel, sendable, fetchAnchorMessage } = params;
+    return {
+        listGuildChannels: async () => {
+            if (!event.guildId)
+                throw new Error("Channel management is only available in guilds.");
+            const guild = await client.guilds.fetch(event.guildId);
+            await guild.channels.fetch();
+            return Array.from(guild.channels.cache.values())
+                .map((c) => ({ id: c.id, name: c.name ?? c.id, type: String(c.type), parentId: c.parentId ?? undefined }))
+                .sort((a, b) => a.name.localeCompare(b.name));
+        },
+        resolveGuildChannel: async (query) => {
+            if (!event.guildId)
+                throw new Error("Channel lookup is only available in guilds.");
+            const guild = await client.guilds.fetch(event.guildId);
+            await guild.channels.fetch();
+            const channels = Array.from(guild.channels.cache.values())
+                .map((c) => ({ id: c.id, name: c.name ?? c.id, type: String(c.type), parentId: c.parentId ?? undefined }));
+            const needle = query.trim().toLowerCase();
+            const exact = channels.find((c) => c.id === query || c.name.toLowerCase() === needle);
+            if (exact)
+                return exact;
+            const partial = channels.filter((c) => c.name.toLowerCase().includes(needle));
+            if (partial.length === 1)
+                return partial[0];
+            if (partial.length === 0)
+                throw new Error(`No channel or category matches: ${query}`);
+            throw new Error(`Channel query is ambiguous: ${partial.slice(0, 8).map((c) => `${c.name} (${c.id})`).join(", ")}`);
+        },
+        resolveGuildMember: async (query) => {
+            if (!event.guildId)
+                throw new Error("Member lookup is only available in guilds.");
+            const guild = await client.guilds.fetch(event.guildId);
+            await guild.members.fetch();
+            const members = Array.from(guild.members.cache.values()).map((m) => ({ id: m.id, userName: m.user?.username ?? m.id, displayName: m.displayName ?? m.user?.username ?? m.id }));
+            const needle = query.trim().toLowerCase();
+            const exact = members.find((m) => m.id === query || m.userName.toLowerCase() === needle || m.displayName.toLowerCase() === needle);
+            if (exact)
+                return exact;
+            const partial = members.filter((m) => m.userName.toLowerCase().includes(needle) || m.displayName.toLowerCase().includes(needle));
+            if (partial.length === 1)
+                return partial[0];
+            if (partial.length === 0)
+                throw new Error(`No guild member matches: ${query}`);
+            throw new Error(`Member query is ambiguous: ${partial.slice(0, 8).map((m) => `${m.displayName} (${m.id})`).join(", ")}`);
+        },
+        resolveGuildRole: async (query) => {
+            if (!event.guildId)
+                throw new Error("Role lookup is only available in guilds.");
+            const guild = await client.guilds.fetch(event.guildId);
+            await guild.roles.fetch();
+            const roles = Array.from(guild.roles.cache.values()).map((r) => ({ id: r.id, name: r.name ?? r.id }));
+            const needle = query.trim().toLowerCase();
+            const exact = roles.find((r) => r.id === query || r.name.toLowerCase() === needle);
+            if (exact)
+                return exact;
+            const partial = roles.filter((r) => r.name.toLowerCase().includes(needle));
+            if (partial.length === 1)
+                return partial[0];
+            if (partial.length === 0)
+                throw new Error(`No role matches: ${query}`);
+            throw new Error(`Role query is ambiguous: ${partial.slice(0, 8).map((r) => `${r.name} (${r.id})`).join(", ")}`);
+        },
+        createGuildTextChannel: async ({ name, parentId, topic, private: isPrivate, memberIds, roleIds }) => {
+            if (!event.guildId)
+                throw new Error("Channel management is only available in guilds.");
+            const guild = await client.guilds.fetch(event.guildId);
+            const overwrites = isPrivate
+                ? [
+                    { id: guild.roles.everyone.id, deny: [PermissionFlagsBits.ViewChannel] },
+                    { id: event.userId, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages, PermissionFlagsBits.ReadMessageHistory] },
+                    ...(memberIds ?? []).filter((id) => id !== event.userId).map((id) => ({ id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages, PermissionFlagsBits.ReadMessageHistory] })),
+                    ...(roleIds ?? []).map((id) => ({ id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages, PermissionFlagsBits.ReadMessageHistory] })),
+                    { id: client.user.id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages, PermissionFlagsBits.ReadMessageHistory, PermissionFlagsBits.ManageChannels, PermissionFlagsBits.CreatePublicThreads, PermissionFlagsBits.CreatePrivateThreads] },
+                ]
+                : undefined;
+            const created = await guild.channels.create({ name, type: ChannelType.GuildText, parent: parentId, topic, permissionOverwrites: overwrites });
+            return { id: created.id, name: "name" in created ? (created.name ?? name) : name };
+        },
+        createGuildCategory: async ({ name }) => {
+            if (!event.guildId)
+                throw new Error("Channel management is only available in guilds.");
+            const guild = await client.guilds.fetch(event.guildId);
+            const created = await guild.channels.create({ name, type: ChannelType.GuildCategory });
+            return { id: created.id, name: "name" in created ? (created.name ?? name) : name };
+        },
+        renameGuildChannel: async ({ channelId, name }) => {
+            const target = await client.channels.fetch(channelId);
+            if (!target || !("setName" in target) || typeof target.setName !== "function")
+                throw new Error(`Channel ${channelId} cannot be renamed.`);
+            const updated = await target.setName(name);
+            return { id: updated.id, name: updated.name ?? name };
+        },
+        moveGuildChannel: async ({ channelId, parentId }) => {
+            const target = await client.channels.fetch(channelId);
+            if (!target || !("setParent" in target) || typeof target.setParent !== "function")
+                throw new Error(`Channel ${channelId} cannot be moved.`);
+            const updated = await target.setParent(parentId ?? null);
+            return { id: updated.id, name: updated.name ?? channelId, parentId: updated.parentId ?? null };
+        },
+        deleteGuildChannel: async ({ channelId }) => {
+            const target = await client.channels.fetch(channelId);
+            if (!target || !("delete" in target) || typeof target.delete !== "function")
+                throw new Error(`Channel ${channelId} cannot be deleted.`);
+            await target.delete();
+            return { id: channelId };
+        },
+        createThreadFromCurrentChannel: async ({ name, autoArchiveDuration }) => {
+            if (channel.isThread())
+                throw new Error("Already in a thread.");
+            const base = await fetchAnchorMessage();
+            if (base && typeof base.startThread === "function") {
+                const thread = await base.startThread({ name, autoArchiveDuration: autoArchiveDuration ?? 1440 });
+                return { id: thread.id, name: thread.name ?? name };
+            }
+            if ("threads" in sendable && sendable.threads?.create) {
+                const thread = await sendable.threads.create({ name, autoArchiveDuration: autoArchiveDuration ?? 1440 });
+                return { id: thread.id, name: thread.name ?? name };
+            }
+            throw new Error("This channel does not support thread creation.");
+        },
+        renameThread: async ({ threadId, name }) => {
+            const target = await client.channels.fetch(threadId);
+            if (!target?.isThread())
+                throw new Error(`Thread ${threadId} not found.`);
+            const updated = await target.setName(name);
+            return { id: updated.id, name: updated.name ?? name };
+        },
+        archiveThread: async ({ threadId, archived, locked }) => {
+            const target = await client.channels.fetch(threadId);
+            if (!target?.isThread())
+                throw new Error(`Thread ${threadId} not found.`);
+            const updated = await target.setArchived(archived ?? true);
+            if (typeof locked === "boolean" && "setLocked" in updated && typeof updated.setLocked === "function") {
+                await updated.setLocked(locked);
+            }
+            return { id: updated.id, archived: archived ?? true, locked };
+        },
+    };
+}

package/dist/discord-interactions.js

@@ -0,0 +1,142 @@
+import * as log from "./log.js";
+async function rejectForeignInteraction(interaction, message) {
+    await interaction.reply({ content: message, ephemeral: true });
+    return true;
+}
+export async function handleSelectMenuInteraction(interaction, state) {
+    const modelRequest = state.pendingModelSelections.get(interaction.customId);
+    if (modelRequest) {
+        if (interaction.user.id !== modelRequest.userId)
+            return rejectForeignInteraction(interaction, "This selector belongs to another user.");
+        state.pendingModelSelections.delete(interaction.customId);
+        await interaction.update({ content: `Selected model: ${interaction.values[0]}`, embeds: [], components: [] });
+        modelRequest.resolve(interaction.values[0] ?? null);
+        return true;
+    }
+    const scopedRequest = state.pendingScopedSelections.get(interaction.customId);
+    if (scopedRequest) {
+        if (interaction.user.id !== scopedRequest.userId)
+            return rejectForeignInteraction(interaction, "This selector belongs to another user.");
+        state.pendingScopedSelections.delete(interaction.customId);
+        await interaction.update({ content: interaction.values.length > 0 ? `Scoped models updated (${interaction.values.length} selected).` : "Scoped models cleared.", embeds: [], components: [] });
+        scopedRequest.resolve(interaction.values);
+        return true;
+    }
+    const treeRequest = state.pendingTreeSelections.get(interaction.customId);
+    if (treeRequest) {
+        if (interaction.user.id !== treeRequest.userId)
+            return rejectForeignInteraction(interaction, "This tree browser belongs to another user.");
+        state.pendingTreeSelections.delete(interaction.customId);
+        await interaction.update({ content: `Navigating to ${interaction.values[0]}...`, embeds: [], components: [] });
+        log.info(`tree navigate selected by ${interaction.user.username}: ${interaction.values[0]}`);
+        treeRequest.resolve(interaction.values[0] ?? null);
+        return true;
+    }
+    return false;
+}
+export async function handleButtonInteraction(interaction, state) {
+    const pageAction = state.pendingModelPages.get(interaction.customId);
+    if (pageAction) {
+        if (interaction.user.id !== pageAction.userId)
+            return rejectForeignInteraction(interaction, "This selector belongs to another user.");
+        state.pendingModelPages.delete(interaction.customId);
+        await interaction.update({ content: interaction.customId.endsWith(":close") ? "Closed." : "Loading models...", embeds: [], components: [] });
+        pageAction.resolve(interaction.customId.endsWith(":prev") ? "prev" : interaction.customId.endsWith(":next") ? "next" : "close");
+        return true;
+    }
+    const scopedPageAction = state.pendingScopedPages.get(interaction.customId);
+    if (scopedPageAction) {
+        if (interaction.user.id !== scopedPageAction.userId)
+            return rejectForeignInteraction(interaction, "This selector belongs to another user.");
+        state.pendingScopedPages.delete(interaction.customId);
+        await interaction.update({ content: interaction.customId.endsWith(":close") ? "Closed." : "Loading scoped models...", embeds: [], components: [] });
+        scopedPageAction.resolve(interaction.customId.endsWith(":prev") ? "prev" : interaction.customId.endsWith(":next") ? "next" : "close");
+        return true;
+    }
+    const settingsAction = state.pendingSettingsActions.get(interaction.customId);
+    if (settingsAction) {
+        if (interaction.user.id !== settingsAction.userId)
+            return rejectForeignInteraction(interaction, "This settings card belongs to another user.");
+        state.pendingSettingsActions.delete(interaction.customId);
+        const action = interaction.customId.split(":").pop();
+        await interaction.update({ content: action === "done" ? "Done." : `Applying settings action: ${action}`, embeds: [], components: [] });
+        settingsAction.resolve(action);
+        return true;
+    }
+    const treePageAction = state.pendingTreePages.get(interaction.customId);
+    if (treePageAction) {
+        if (interaction.user.id !== treePageAction.userId)
+            return rejectForeignInteraction(interaction, "This tree browser belongs to another user.");
+        state.pendingTreePages.delete(interaction.customId);
+        await interaction.update({ content: interaction.customId.endsWith(":close") ? "Closed." : "Loading session tree...", embeds: [], components: [] });
+        treePageAction.resolve(interaction.customId.endsWith(":prev") ? "prev" : interaction.customId.endsWith(":next") ? "next" : "close");
+        return true;
+    }
+    const approval = state.pendingApprovals.get(interaction.customId);
+    if (approval) {
+        if (interaction.user.id !== approval.userId)
+            return rejectForeignInteraction(interaction, "This approval belongs to another user.");
+        const baseId = interaction.customId.replace(/:(approve|reject)$/, "");
+        state.pendingApprovals.delete(`${baseId}:approve`);
+        state.pendingApprovals.delete(`${baseId}:reject`);
+        const approved = interaction.customId.endsWith(":approve");
+        await interaction.update({ content: approved ? "Approved." : "Cancelled.", embeds: [], components: [] });
+        log.info(`approval ${approved ? "approved" : "cancelled"} by ${interaction.user.username}`);
+        approval.resolve(approved);
+        return true;
+    }
+    return false;
+}
+export function slashCommandToText(interaction) {
+    if (interaction.commandName === "pi")
+        return interaction.options.getString("prompt", true).trim();
+    if (interaction.commandName === "new")
+        return "/new";
+    if (interaction.commandName === "name")
+        return `/name ${interaction.options.getString("name", true).trim()}`;
+    if (interaction.commandName === "session")
+        return "/session";
+    if (interaction.commandName === "tree") {
+        const entryId = interaction.options.getString("entry_id")?.trim();
+        return entryId ? `/tree ${entryId}` : "/tree";
+    }
+    if (interaction.commandName === "model") {
+        const reference = interaction.options.getString("reference")?.trim();
+        return reference ? `/model ${reference}` : "/model";
+    }
+    if (interaction.commandName === "scoped-models") {
+        const patterns = interaction.options.getString("patterns")?.trim();
+        return patterns ? `/scoped-models ${patterns}` : "/scoped-models";
+    }
+    if (interaction.commandName === "settings")
+        return "/settings";
+    if (interaction.commandName === "compact") {
+        const instructions = interaction.options.getString("instructions")?.trim();
+        return instructions ? `/compact ${instructions}` : "/compact";
+    }
+    if (interaction.commandName === "reload")
+        return "/reload";
+    if (interaction.commandName === "login") {
+        const provider = interaction.options.getString("provider")?.trim();
+        return provider ? `/login ${provider}` : "/login";
+    }
+    if (interaction.commandName === "logout") {
+        const provider = interaction.options.getString("provider")?.trim();
+        return provider ? `/logout ${provider}` : "/logout";
+    }
+    return null;
+}
+export function buildSlashEvent(interaction, text) {
+    return {
+        type: "slash",
+        source: "slash",
+        channelId: interaction.channelId,
+        guildId: interaction.guildId ?? undefined,
+        threadId: interaction.channel?.isThread() ? interaction.channel.id : undefined,
+        messageId: interaction.id,
+        userId: interaction.user.id,
+        userName: interaction.user.username,
+        text,
+        attachments: [],
+    };
+}

package/dist/discord-policy.js

@@ -0,0 +1,90 @@
+import { ApplicationCommandOptionType, ChannelType } from "discord.js";
+import { existsSync, readFileSync } from "node:fs";
+import * as log from "./log.js";
+export function loadDiscordPolicy(policyPath) {
+    if (!existsSync(policyPath)) {
+        return {
+            allowDMs: true,
+            mentionMode: "mention-only",
+            slashCommands: { enabled: true, guildId: process.env.DISCORD_GUILD_ID },
+        };
+    }
+    try {
+        return JSON.parse(readFileSync(policyPath, "utf-8"));
+    }
+    catch (err) {
+        log.warn("failed to parse discord-policy.json", err instanceof Error ? err.message : String(err));
+        return { allowDMs: true, mentionMode: "mention-only", slashCommands: { enabled: true } };
+    }
+}
+export function buildSlashCommands() {
+    return [
+        {
+            name: "pi",
+            description: "Ask the Pi-powered Discord bot to do something",
+            options: [{ name: "prompt", description: "What should the bot do?", type: ApplicationCommandOptionType.String, required: true }],
+        },
+        { name: "stop", description: "Abort the current run for this conversation" },
+        { name: "new", description: "Start a new Pi session for this conversation" },
+        {
+            name: "name",
+            description: "Set the current Pi session name",
+            options: [{ name: "name", description: "New session name", type: ApplicationCommandOptionType.String, required: true }],
+        },
+        { name: "session", description: "Show current Pi session information" },
+        {
+            name: "tree",
+            description: "Show or navigate the current Pi session tree",
+            options: [{ name: "entry_id", description: "Optional session entry id to navigate to", type: ApplicationCommandOptionType.String, required: false }],
+        },
+        {
+            name: "model",
+            description: "Show or change the current Pi model",
+            options: [{ name: "reference", description: "provider/model or search string", type: ApplicationCommandOptionType.String, required: false }],
+        },
+        {
+            name: "scoped-models",
+            description: "Show or set Pi scoped models",
+            options: [{ name: "patterns", description: "Comma-separated model patterns, or clear", type: ApplicationCommandOptionType.String, required: false }],
+        },
+        { name: "settings", description: "Show current Pi settings summary" },
+        {
+            name: "compact",
+            description: "Compact the current Pi session",
+            options: [{ name: "instructions", description: "Optional custom compaction instructions", type: ApplicationCommandOptionType.String, required: false }],
+        },
+        { name: "reload", description: "Reload Pi resources" },
+        {
+            name: "login",
+            description: "Show how to log in with shared Pi auth",
+            options: [{ name: "provider", description: "Optional provider name", type: ApplicationCommandOptionType.String, required: false }],
+        },
+        {
+            name: "logout",
+            description: "Show how to log out from shared Pi auth",
+            options: [{ name: "provider", description: "Optional provider name", type: ApplicationCommandOptionType.String, required: false }],
+        },
+    ];
+}
+export function isAllowedDiscordMessage(message, botUserId, policy) {
+    const isDm = message.channel.type === ChannelType.DM;
+    const trimmed = message.content.trim();
+    const isTextCommand = trimmed.startsWith("/");
+    if (isDm) {
+        if (policy.allowDMs === false)
+            return { allowed: false, reason: "DMs disabled by policy" };
+        return { allowed: true };
+    }
+    if (policy.guildIds?.length && (!message.guildId || !policy.guildIds.includes(message.guildId))) {
+        return { allowed: false, reason: "guild not in allowlist" };
+    }
+    const effectiveChannelId = message.channel.isThread() ? message.channel.parentId ?? message.channel.id : message.channel.id;
+    if (policy.channelIds?.length && !policy.channelIds.includes(effectiveChannelId) && !policy.channelIds.includes(message.channel.id)) {
+        return { allowed: false, reason: "channel not in allowlist" };
+    }
+    const mentionMode = policy.mentionMode ?? "mention-only";
+    if (mentionMode === "mention-only" && !message.mentions.users.has(botUserId) && !isTextCommand) {
+        return { allowed: false, reason: "no mention" };
+    }
+    return { allowed: true };
+}

package/dist/discord-registry.js

@@ -0,0 +1,22 @@
+export function registerPending(params) {
+    params.registry.set(params.key, { userId: params.userId, resolve: params.resolve });
+}
+export function registerManyPending(params) {
+    for (const key of params.keys) {
+        params.registry.set(key, { userId: params.userId, resolve: params.resolve });
+    }
+}
+export function clearPending(registry, keys) {
+    let hadAny = false;
+    for (const key of keys) {
+        if (!key)
+            continue;
+        hadAny = registry.delete(key) || hadAny;
+    }
+    return hadAny;
+}
+export function resolveOnTimeout(params) {
+    setTimeout(() => {
+        params.run();
+    }, params.timeoutMs ?? 120000);
+}

package/dist/discord-registry.test.js

@@ -0,0 +1,17 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { clearPending, registerManyPending, registerPending } from "./discord-registry.js";
+test("registerPending stores a single entry", () => {
+    const registry = new Map();
+    const resolve = () => { };
+    registerPending({ registry, key: "a", userId: "u1", resolve });
+    assert.equal(registry.get("a")?.userId, "u1");
+});
+test("registerManyPending and clearPending work together", () => {
+    const registry = new Map();
+    const resolve = () => { };
+    registerManyPending({ registry, keys: ["a", "b", "c"], userId: "u1", resolve });
+    assert.equal(registry.size, 3);
+    assert.equal(clearPending(registry, ["a", "c", "missing"]), true);
+    assert.deepEqual([...registry.keys()], ["b"]);
+});

package/dist/discord-types.js

@@ -0,0 +1 @@
+export {};