@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/discord/send.permissions.js

@@ -1,46 +1,30 @@
-import { RequestClient } from "@buape/carbon";
 import { ChannelType, PermissionFlagsBits, Routes } from "discord-api-types/v10";
-import { loadConfig } from "../config/config.js";
-import { resolveDiscordAccount } from "./accounts.js";
-import { normalizeDiscordToken } from "./token.js";
+import { resolveDiscordRest } from "./client.js";
 const PERMISSION_ENTRIES = Object.entries(PermissionFlagsBits).filter(([, value]) => typeof value === "bigint");
-function resolveToken(params) {
-    const explicit = normalizeDiscordToken(params.explicit);
-    if (explicit)
-        return explicit;
-    const fallback = normalizeDiscordToken(params.fallbackToken);
-    if (!fallback) {
-        throw new Error(`Discord bot token missing for account "${params.accountId}" (set discord.accounts.${params.accountId}.token or DISCORD_BOT_TOKEN for default).`);
-    }
-    return fallback;
-}
-function resolveRest(token, rest) {
-    return rest ?? new RequestClient(token);
-}
-function resolveDiscordRest(opts) {
-    const cfg = loadConfig();
-    const account = resolveDiscordAccount({ cfg, accountId: opts.accountId });
-    const token = resolveToken({
-        explicit: opts.token,
-        accountId: account.accountId,
-        fallbackToken: account.token,
-    });
-    return resolveRest(token, opts.rest);
-}
+const ALL_PERMISSIONS = PERMISSION_ENTRIES.reduce((acc, [, value]) => acc | value, 0n);
+const ADMINISTRATOR_BIT = PermissionFlagsBits.Administrator;
 function addPermissionBits(base, add) {
-    if (!add)
+    if (!add) {
         return base;
+    }
     return base | BigInt(add);
 }
 function removePermissionBits(base, deny) {
-    if (!deny)
+    if (!deny) {
         return base;
+    }
     return base & ~BigInt(deny);
 }
 function bitfieldToPermissions(bitfield) {
     return PERMISSION_ENTRIES.filter(([, value]) => (bitfield & value) === value)
         .map(([name]) => name)
-        .sort();
+        .toSorted();
+}
+function hasAdministrator(bitfield) {
+    return (bitfield & ADMINISTRATOR_BIT) === ADMINISTRATOR_BIT;
+}
+function hasPermissionBit(bitfield, permission) {
+    return (bitfield & permission) === permission;
 }
 export function isThreadChannelType(channelType) {
     return (channelType === ChannelType.GuildNewsThread ||
@@ -54,6 +38,65 @@ async function fetchBotUserId(rest) {
     }
     return me.id;
 }
+/**
+ * Fetch guild-level permissions for a user. This does not include channel-specific overwrites.
+ */
+export async function fetchMemberGuildPermissionsDiscord(guildId, userId, opts = {}) {
+    const rest = resolveDiscordRest(opts);
+    try {
+        const [guild, member] = await Promise.all([
+            rest.get(Routes.guild(guildId)),
+            rest.get(Routes.guildMember(guildId, userId)),
+        ]);
+        const rolesById = new Map((guild.roles ?? []).map((role) => [role.id, role]));
+        const everyoneRole = rolesById.get(guildId);
+        let permissions = 0n;
+        if (everyoneRole?.permissions) {
+            permissions = addPermissionBits(permissions, everyoneRole.permissions);
+        }
+        for (const roleId of member.roles ?? []) {
+            const role = rolesById.get(roleId);
+            if (role?.permissions) {
+                permissions = addPermissionBits(permissions, role.permissions);
+            }
+        }
+        return permissions;
+    }
+    catch {
+        // Not a guild member, guild not found, or API failure.
+        return null;
+    }
+}
+/**
+ * Returns true when the user has ADMINISTRATOR or any required permission bit.
+ */
+export async function hasAnyGuildPermissionDiscord(guildId, userId, requiredPermissions, opts = {}) {
+    const permissions = await fetchMemberGuildPermissionsDiscord(guildId, userId, opts);
+    if (permissions === null) {
+        return false;
+    }
+    if (hasAdministrator(permissions)) {
+        return true;
+    }
+    return requiredPermissions.some((permission) => hasPermissionBit(permissions, permission));
+}
+/**
+ * Returns true when the user has ADMINISTRATOR or all required permission bits.
+ */
+export async function hasAllGuildPermissionsDiscord(guildId, userId, requiredPermissions, opts = {}) {
+    const permissions = await fetchMemberGuildPermissionsDiscord(guildId, userId, opts);
+    if (permissions === null) {
+        return false;
+    }
+    if (hasAdministrator(permissions)) {
+        return true;
+    }
+    return requiredPermissions.every((permission) => hasPermissionBit(permissions, permission));
+}
+/**
+ * @deprecated Prefer hasAnyGuildPermissionDiscord or hasAllGuildPermissionsDiscord for clarity.
+ */
+export const hasGuildPermissionDiscord = hasAnyGuildPermissionDiscord;
 export async function fetchChannelPermissionsDiscord(channelId, opts = {}) {
     const rest = resolveDiscordRest(opts);
     const channel = (await rest.get(Routes.channel(channelId)));
@@ -85,6 +128,16 @@ export async function fetchChannelPermissionsDiscord(channelId, opts = {}) {
             base = addPermissionBits(base, role.permissions);
         }
     }
+    if (hasAdministrator(base)) {
+        return {
+            channelId,
+            guildId,
+            permissions: bitfieldToPermissions(ALL_PERMISSIONS),
+            raw: ALL_PERMISSIONS.toString(),
+            isDm: false,
+            channelType,
+        };
+    }
     let permissions = base;
     const overwrites = "permission_overwrites" in channel ? (channel.permission_overwrites ?? []) : [];
     for (const overwrite of overwrites) {

package/dist/discord/send.reactions.js

@@ -20,11 +20,13 @@ export async function removeOwnReactionsDiscord(channelId, messageId, opts = {})
     const identifiers = new Set();
     for (const reaction of message.reactions ?? []) {
         const identifier = buildReactionIdentifier(reaction.emoji);
-        if (identifier)
+        if (identifier) {
             identifiers.add(identifier);
+        }
     }
-    if (identifiers.size === 0)
+    if (identifiers.size === 0) {
         return { ok: true, removed: [] };
+    }
     const removed = [];
     await Promise.allSettled(Array.from(identifiers, (identifier) => {
         removed.push(identifier);
@@ -36,16 +38,18 @@ export async function fetchReactionsDiscord(channelId, messageId, opts = {}) {
     const rest = resolveDiscordRest(opts);
     const message = (await rest.get(Routes.channelMessage(channelId, messageId)));
     const reactions = message.reactions ?? [];
-    if (reactions.length === 0)
+    if (reactions.length === 0) {
         return [];
+    }
     const limit = typeof opts.limit === "number" && Number.isFinite(opts.limit)
         ? Math.min(Math.max(Math.floor(opts.limit), 1), 100)
         : 100;
     const summaries = [];
     for (const reaction of reactions) {
         const identifier = buildReactionIdentifier(reaction.emoji);
-        if (!identifier)
+        if (!identifier) {
             continue;
+        }
         const encoded = encodeURIComponent(identifier);
         const users = (await rest.get(Routes.channelMessageReaction(channelId, messageId, encoded), {
             limit,

package/dist/discord/token.js

@@ -1,10 +1,12 @@
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";
 export function normalizeDiscordToken(raw) {
-    if (!raw)
+    if (!raw) {
         return undefined;
+    }
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return undefined;
+    }
     return trimmed.replace(/^Bot\s+/i, "");
 }
 export function resolveDiscordToken(cfg, opts = {}) {
@@ -14,16 +16,19 @@ export function resolveDiscordToken(cfg, opts = {}) {
         ? discordCfg?.accounts?.[accountId]
         : discordCfg?.accounts?.[DEFAULT_ACCOUNT_ID];
     const accountToken = normalizeDiscordToken(accountCfg?.token ?? undefined);
-    if (accountToken)
+    if (accountToken) {
         return { token: accountToken, source: "config" };
+    }
     const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
     const configToken = allowEnv ? normalizeDiscordToken(discordCfg?.token ?? undefined) : undefined;
-    if (configToken)
+    if (configToken) {
         return { token: configToken, source: "config" };
+    }
     const envToken = allowEnv
         ? normalizeDiscordToken(opts.envToken ?? process.env.DISCORD_BOT_TOKEN)
         : undefined;
-    if (envToken)
+    if (envToken) {
         return { token: envToken, source: "env" };
+    }
     return { token: "", source: "none" };
 }

package/dist/discord/voice/command.js

@@ -0,0 +1,263 @@
+import { ChannelType as CarbonChannelType, Command, CommandWithSubcommands, } from "@buape/carbon";
+import { ApplicationCommandOptionType, ChannelType as DiscordChannelType, } from "discord-api-types/v10";
+import { resolveCommandAuthorizedFromAuthorizers } from "../../channels/command-gating.js";
+import { allowListMatches, isDiscordGroupAllowedByPolicy, normalizeDiscordAllowList, normalizeDiscordSlug, resolveDiscordChannelConfigWithFallback, resolveDiscordGuildEntry, resolveDiscordMemberAccessState, } from "../monitor/allow-list.js";
+import { resolveDiscordChannelInfo } from "../monitor/message-utils.js";
+import { resolveDiscordSenderIdentity } from "../monitor/sender-identity.js";
+import { resolveDiscordThreadParentInfo } from "../monitor/threading.js";
+const VOICE_CHANNEL_TYPES = [
+    DiscordChannelType.GuildVoice,
+    DiscordChannelType.GuildStageVoice,
+];
+async function authorizeVoiceCommand(interaction, params, options) {
+    const channelOverride = options?.channelOverride;
+    const channel = channelOverride ? undefined : interaction.channel;
+    if (!interaction.guild) {
+        return { ok: false, message: "Voice commands are only available in guilds." };
+    }
+    const user = interaction.user;
+    if (!user) {
+        return { ok: false, message: "Unable to resolve command user." };
+    }
+    const channelId = channelOverride?.id ?? channel?.id ?? "";
+    const rawChannelName = channelOverride?.name ?? (channel && "name" in channel ? channel.name : undefined);
+    const rawParentId = channelOverride?.parentId ??
+        ("parentId" in (channel ?? {})
+            ? (channel.parentId ?? undefined)
+            : undefined);
+    const channelInfo = channelId
+        ? await resolveDiscordChannelInfo(interaction.client, channelId)
+        : null;
+    const channelName = rawChannelName ?? channelInfo?.name;
+    const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
+    const isThreadChannel = channelInfo?.type === CarbonChannelType.PublicThread ||
+        channelInfo?.type === CarbonChannelType.PrivateThread ||
+        channelInfo?.type === CarbonChannelType.AnnouncementThread;
+    let parentId;
+    let parentName;
+    let parentSlug;
+    if (isThreadChannel && channelId) {
+        const parentInfo = await resolveDiscordThreadParentInfo({
+            client: interaction.client,
+            threadChannel: {
+                id: channelId,
+                name: channelName,
+                parentId: rawParentId ?? channelInfo?.parentId,
+                parent: undefined,
+            },
+            channelInfo,
+        });
+        parentId = parentInfo.id;
+        parentName = parentInfo.name;
+        parentSlug = parentName ? normalizeDiscordSlug(parentName) : undefined;
+    }
+    const guildInfo = resolveDiscordGuildEntry({
+        guild: interaction.guild ?? undefined,
+        guildEntries: params.discordConfig.guilds,
+    });
+    const channelConfig = channelId
+        ? resolveDiscordChannelConfigWithFallback({
+            guildInfo,
+            channelId,
+            channelName,
+            channelSlug,
+            parentId,
+            parentName,
+            parentSlug,
+            scope: isThreadChannel ? "thread" : "channel",
+        })
+        : null;
+    if (channelConfig?.enabled === false) {
+        return { ok: false, message: "This channel is disabled." };
+    }
+    const channelAllowlistConfigured = Boolean(guildInfo?.channels) && Object.keys(guildInfo?.channels ?? {}).length > 0;
+    const channelAllowed = channelConfig?.allowed !== false;
+    if (!isDiscordGroupAllowedByPolicy({
+        groupPolicy: params.groupPolicy,
+        guildAllowlisted: Boolean(guildInfo),
+        channelAllowlistConfigured,
+        channelAllowed,
+    }) ||
+        channelConfig?.allowed === false) {
+        const channelId = channelOverride?.id ?? channel?.id;
+        const channelLabel = channelId ? `<#${channelId}>` : "This channel";
+        return {
+            ok: false,
+            message: `${channelLabel} is not allowlisted for voice commands.`,
+        };
+    }
+    const memberRoleIds = Array.isArray(interaction.rawData.member?.roles)
+        ? interaction.rawData.member.roles.map((roleId) => String(roleId))
+        : [];
+    const sender = resolveDiscordSenderIdentity({ author: user, member: interaction.rawData.member });
+    const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
+        channelConfig,
+        guildInfo,
+        memberRoleIds,
+        sender,
+    });
+    const ownerAllowList = normalizeDiscordAllowList(params.discordConfig.allowFrom ?? params.discordConfig.dm?.allowFrom ?? [], ["discord:", "user:", "pk:"]);
+    const ownerOk = ownerAllowList
+        ? allowListMatches(ownerAllowList, {
+            id: sender.id,
+            name: sender.name,
+            tag: sender.tag,
+        })
+        : false;
+    const authorizers = params.useAccessGroups
+        ? [
+            { configured: ownerAllowList != null, allowed: ownerOk },
+            { configured: hasAccessRestrictions, allowed: memberAllowed },
+        ]
+        : [{ configured: hasAccessRestrictions, allowed: memberAllowed }];
+    const commandAuthorized = resolveCommandAuthorizedFromAuthorizers({
+        useAccessGroups: params.useAccessGroups,
+        authorizers,
+        modeWhenAccessGroupsOff: "configured",
+    });
+    if (!commandAuthorized) {
+        return { ok: false, message: "You are not authorized to use this command." };
+    }
+    return { ok: true, guildId: interaction.guild.id };
+}
+export function createDiscordVoiceCommand(params) {
+    const resolveSessionChannelId = (manager, guildId) => manager.status().find((entry) => entry.guildId === guildId)?.channelId;
+    class JoinCommand extends Command {
+        name = "join";
+        description = "Join a voice channel";
+        defer = true;
+        ephemeral = params.ephemeralDefault;
+        options = [
+            {
+                name: "channel",
+                description: "Voice channel to join",
+                type: ApplicationCommandOptionType.Channel,
+                required: true,
+                channel_types: VOICE_CHANNEL_TYPES,
+            },
+        ];
+        async run(interaction) {
+            const channel = await interaction.options.getChannel("channel", true);
+            if (!channel || !("id" in channel)) {
+                await interaction.reply({ content: "Voice channel not found.", ephemeral: true });
+                return;
+            }
+            const access = await authorizeVoiceCommand(interaction, params, {
+                channelOverride: {
+                    id: channel.id,
+                    name: "name" in channel ? channel.name : undefined,
+                    parentId: "parentId" in channel
+                        ? (channel.parentId ?? undefined)
+                        : undefined,
+                },
+            });
+            if (!access.ok) {
+                await interaction.reply({ content: access.message ?? "Not authorized.", ephemeral: true });
+                return;
+            }
+            if (!isVoiceChannelType(channel.type)) {
+                await interaction.reply({ content: "That is not a voice channel.", ephemeral: true });
+                return;
+            }
+            const guildId = access.guildId ?? ("guildId" in channel ? channel.guildId : undefined);
+            if (!guildId) {
+                await interaction.reply({
+                    content: "Unable to resolve guild for this voice channel.",
+                    ephemeral: true,
+                });
+                return;
+            }
+            const manager = params.getManager();
+            if (!manager) {
+                await interaction.reply({
+                    content: "Voice manager is not available yet.",
+                    ephemeral: true,
+                });
+                return;
+            }
+            const result = await manager.join({ guildId, channelId: channel.id });
+            await interaction.reply({ content: result.message, ephemeral: true });
+        }
+    }
+    class LeaveCommand extends Command {
+        name = "leave";
+        description = "Leave the current voice channel";
+        defer = true;
+        ephemeral = params.ephemeralDefault;
+        async run(interaction) {
+            const guildId = interaction.guild?.id;
+            if (!guildId) {
+                await interaction.reply({
+                    content: "Unable to resolve guild for this command.",
+                    ephemeral: true,
+                });
+                return;
+            }
+            const manager = params.getManager();
+            if (!manager) {
+                await interaction.reply({
+                    content: "Voice manager is not available yet.",
+                    ephemeral: true,
+                });
+                return;
+            }
+            const sessionChannelId = resolveSessionChannelId(manager, guildId);
+            const access = await authorizeVoiceCommand(interaction, params, {
+                channelOverride: sessionChannelId ? { id: sessionChannelId } : undefined,
+            });
+            if (!access.ok) {
+                await interaction.reply({ content: access.message ?? "Not authorized.", ephemeral: true });
+                return;
+            }
+            const result = await manager.leave({ guildId });
+            await interaction.reply({ content: result.message, ephemeral: true });
+        }
+    }
+    class StatusCommand extends Command {
+        name = "status";
+        description = "Show active voice sessions";
+        defer = true;
+        ephemeral = params.ephemeralDefault;
+        async run(interaction) {
+            const guildId = interaction.guild?.id;
+            if (!guildId) {
+                await interaction.reply({
+                    content: "Unable to resolve guild for this command.",
+                    ephemeral: true,
+                });
+                return;
+            }
+            const manager = params.getManager();
+            if (!manager) {
+                await interaction.reply({
+                    content: "Voice manager is not available yet.",
+                    ephemeral: true,
+                });
+                return;
+            }
+            const sessions = manager.status().filter((entry) => entry.guildId === guildId);
+            const sessionChannelId = sessions[0]?.channelId;
+            const access = await authorizeVoiceCommand(interaction, params, {
+                channelOverride: sessionChannelId ? { id: sessionChannelId } : undefined,
+            });
+            if (!access.ok) {
+                await interaction.reply({ content: access.message ?? "Not authorized.", ephemeral: true });
+                return;
+            }
+            if (sessions.length === 0) {
+                await interaction.reply({ content: "No active voice sessions.", ephemeral: true });
+                return;
+            }
+            const lines = sessions.map((entry) => `\u2022 <#${entry.channelId}> (guild ${entry.guildId})`);
+            await interaction.reply({ content: lines.join("\n"), ephemeral: true });
+        }
+    }
+    return new (class extends CommandWithSubcommands {
+        name = "vc";
+        description = "Voice channel controls";
+        subcommands = [new JoinCommand(), new LeaveCommand(), new StatusCommand()];
+    })();
+}
+function isVoiceChannelType(type) {
+    return type === CarbonChannelType.GuildVoice || type === CarbonChannelType.GuildStageVoice;
+}