@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/discord/monitor/provider.allowlist.js

@@ -0,0 +1,223 @@
+import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, canonicalizeAllowlistWithResolvedIds, patchAllowlistUsersInConfigEntries, summarizeMapping, } from "../../channels/allowlists/resolve-utils.js";
+import { formatErrorMessage } from "../../infra/errors.js";
+import { resolveDiscordChannelAllowlist } from "../resolve-channels.js";
+import { resolveDiscordUserAllowlist } from "../resolve-users.js";
+function toGuildEntries(value) {
+    if (!value || typeof value !== "object") {
+        return {};
+    }
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (!entry || typeof entry !== "object") {
+            continue;
+        }
+        out[key] = entry;
+    }
+    return out;
+}
+function toAllowlistEntries(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    return value.map((entry) => String(entry).trim()).filter((entry) => Boolean(entry));
+}
+function hasGuildEntries(value) {
+    return Object.keys(value).length > 0;
+}
+function collectChannelResolutionInputs(guildEntries) {
+    const entries = [];
+    for (const [guildKey, guildCfg] of Object.entries(guildEntries)) {
+        if (guildKey === "*") {
+            continue;
+        }
+        const channels = guildCfg?.channels ?? {};
+        const channelKeys = Object.keys(channels).filter((key) => key !== "*");
+        if (channelKeys.length === 0) {
+            const input = /^\d+$/.test(guildKey) ? `guild:${guildKey}` : guildKey;
+            entries.push({ input, guildKey });
+            continue;
+        }
+        for (const channelKey of channelKeys) {
+            entries.push({
+                input: `${guildKey}/${channelKey}`,
+                guildKey,
+                channelKey,
+            });
+        }
+    }
+    return entries;
+}
+async function resolveGuildEntriesByChannelAllowlist(params) {
+    const entries = collectChannelResolutionInputs(params.guildEntries);
+    if (entries.length === 0) {
+        return params.guildEntries;
+    }
+    try {
+        const resolved = await resolveDiscordChannelAllowlist({
+            token: params.token,
+            entries: entries.map((entry) => entry.input),
+            fetcher: params.fetcher,
+        });
+        const sourceByInput = new Map(entries.map((entry) => [entry.input, entry]));
+        const nextGuilds = { ...params.guildEntries };
+        const mapping = [];
+        const unresolved = [];
+        for (const entry of resolved) {
+            const source = sourceByInput.get(entry.input);
+            if (!source) {
+                continue;
+            }
+            const sourceGuild = params.guildEntries[source.guildKey] ?? {};
+            if (!entry.resolved || !entry.guildId) {
+                unresolved.push(entry.input);
+                continue;
+            }
+            mapping.push(entry.channelId
+                ? `${entry.input}→${entry.guildId}/${entry.channelId}`
+                : `${entry.input}→${entry.guildId}`);
+            const existing = nextGuilds[entry.guildId] ?? {};
+            const mergedChannels = {
+                ...sourceGuild.channels,
+                ...existing.channels,
+            };
+            const mergedGuild = {
+                ...sourceGuild,
+                ...existing,
+                channels: mergedChannels,
+            };
+            nextGuilds[entry.guildId] = mergedGuild;
+            if (source.channelKey && entry.channelId) {
+                const sourceChannel = sourceGuild.channels?.[source.channelKey];
+                if (sourceChannel) {
+                    nextGuilds[entry.guildId] = {
+                        ...mergedGuild,
+                        channels: {
+                            ...mergedChannels,
+                            [entry.channelId]: {
+                                ...sourceChannel,
+                                ...mergedChannels[entry.channelId],
+                            },
+                        },
+                    };
+                }
+            }
+        }
+        summarizeMapping("discord channels", mapping, unresolved, params.runtime);
+        return nextGuilds;
+    }
+    catch (err) {
+        params.runtime.log?.(`discord channel resolve failed; using config entries. ${formatErrorMessage(err)}`);
+        return params.guildEntries;
+    }
+}
+async function resolveAllowFromByUserAllowlist(params) {
+    const allowEntries = params.allowFrom?.filter((entry) => String(entry).trim() && String(entry).trim() !== "*") ?? [];
+    if (allowEntries.length === 0) {
+        return params.allowFrom;
+    }
+    try {
+        const resolvedUsers = await resolveDiscordUserAllowlist({
+            token: params.token,
+            entries: allowEntries.map((entry) => String(entry)),
+            fetcher: params.fetcher,
+        });
+        const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(resolvedUsers);
+        const allowFrom = canonicalizeAllowlistWithResolvedIds({
+            existing: params.allowFrom,
+            resolvedMap,
+        });
+        summarizeMapping("discord users", mapping, unresolved, params.runtime);
+        return allowFrom;
+    }
+    catch (err) {
+        params.runtime.log?.(`discord user resolve failed; using config entries. ${formatErrorMessage(err)}`);
+        return params.allowFrom;
+    }
+}
+function collectGuildUserEntries(guildEntries) {
+    const userEntries = new Set();
+    for (const guild of Object.values(guildEntries)) {
+        if (!guild || typeof guild !== "object") {
+            continue;
+        }
+        addAllowlistUserEntriesFromConfigEntry(userEntries, guild);
+        const channels = guild.channels ?? {};
+        for (const channel of Object.values(channels)) {
+            addAllowlistUserEntriesFromConfigEntry(userEntries, channel);
+        }
+    }
+    return userEntries;
+}
+async function resolveGuildEntriesByUserAllowlist(params) {
+    const userEntries = collectGuildUserEntries(params.guildEntries);
+    if (userEntries.size === 0) {
+        return params.guildEntries;
+    }
+    try {
+        const resolvedUsers = await resolveDiscordUserAllowlist({
+            token: params.token,
+            entries: Array.from(userEntries),
+            fetcher: params.fetcher,
+        });
+        const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(resolvedUsers);
+        const nextGuilds = { ...params.guildEntries };
+        for (const [guildKey, guildConfig] of Object.entries(params.guildEntries)) {
+            if (!guildConfig || typeof guildConfig !== "object") {
+                continue;
+            }
+            const nextGuild = { ...guildConfig };
+            const users = guildConfig.users;
+            if (Array.isArray(users) && users.length > 0) {
+                nextGuild.users = canonicalizeAllowlistWithResolvedIds({
+                    existing: users,
+                    resolvedMap,
+                });
+            }
+            const channels = guildConfig.channels ?? {};
+            if (channels && typeof channels === "object") {
+                nextGuild.channels = patchAllowlistUsersInConfigEntries({
+                    entries: channels,
+                    resolvedMap,
+                    strategy: "canonicalize",
+                });
+            }
+            nextGuilds[guildKey] = nextGuild;
+        }
+        summarizeMapping("discord channel users", mapping, unresolved, params.runtime);
+        return nextGuilds;
+    }
+    catch (err) {
+        params.runtime.log?.(`discord channel user resolve failed; using config entries. ${formatErrorMessage(err)}`);
+        return params.guildEntries;
+    }
+}
+export async function resolveDiscordAllowlistConfig(params) {
+    let guildEntries = toGuildEntries(params.guildEntries);
+    let allowFrom = toAllowlistEntries(params.allowFrom);
+    if (hasGuildEntries(guildEntries)) {
+        guildEntries = await resolveGuildEntriesByChannelAllowlist({
+            token: params.token,
+            guildEntries,
+            fetcher: params.fetcher,
+            runtime: params.runtime,
+        });
+    }
+    allowFrom = await resolveAllowFromByUserAllowlist({
+        token: params.token,
+        allowFrom,
+        fetcher: params.fetcher,
+        runtime: params.runtime,
+    });
+    if (hasGuildEntries(guildEntries)) {
+        guildEntries = await resolveGuildEntriesByUserAllowlist({
+            token: params.token,
+            guildEntries,
+            fetcher: params.fetcher,
+            runtime: params.runtime,
+        });
+    }
+    return {
+        guildEntries: hasGuildEntries(guildEntries) ? guildEntries : undefined,
+        allowFrom,
+    };
+}