Fetch channel references for all uses in all components

Author: jeremy-rifkin

src/bot-utilities.ts

@@ -2,7 +2,7 @@ import { strict as assert } from "assert";
 
 import * as Discord from "discord.js";
 
-import { named_id, Wheatley } from "./wheatley.js";
+import { named_id, Wheatley, channels_map, resolved_channels, typed_channel_id } from "./wheatley.js";
 import { decode_snowflake, is_media_link_embed, make_url, get_thread_owner } from "./utils/discord.js";
 import { unwrap } from "./utils/misc.js";
 import { colors } from "./common.js";
@@ -371,6 +371,15 @@ export class BotUtilities {
         return channel;
     }
 
+    async get_voice_channel(channel_info: named_id) {
+        const channel = await this.get_channel_internal(channel_info);
+        assert(
+            channel instanceof Discord.VoiceChannel,
+            `Channel ${channel?.name} (${channel_info.id}) not of the expected type`,
+        );
+        return channel;
+    }
+
     async get_forum_channel(channel_info: named_id) {
         const channel = await this.get_channel_internal(channel_info);
 
@@ -404,6 +413,43 @@ export class BotUtilities {
         return category;
     }
 
+    async resolve_channels<const K extends readonly (keyof channels_map)[]>(
+        ...keys: K
+    ): Promise<resolved_channels<K[number]>> {
+        const result: Record<string, Discord.Channel> = {};
+        for (const key of keys) {
+            const channel_info = this.wheatley.channels[key];
+            switch (channel_info.type) {
+                case "text":
+                    result[key] = await this.get_channel(channel_info);
+                    break;
+                case "forum":
+                    result[key] = await this.get_forum_channel(channel_info);
+                    break;
+                case "voice":
+                    result[key] = await this.get_voice_channel(channel_info);
+                    break;
+                case "thread":
+                    result[key] = await this.get_thread_channel(channel_info);
+                    break;
+            }
+        }
+        return result as resolved_channels<K[number]>;
+    }
+
+    async resolve_channel(channel_info: typed_channel_id): Promise<Discord.Channel> {
+        switch (channel_info.type) {
+            case "text":
+                return this.get_channel(channel_info);
+            case "forum":
+                return this.get_forum_channel(channel_info);
+            case "voice":
+                return this.get_voice_channel(channel_info);
+            case "thread":
+                return this.get_thread_channel(channel_info);
+        }
+    }
+
     async can_user_control_thread(user: Discord.User, thread: Discord.ThreadChannel) {
         try {
             const owner_id = await get_thread_owner(thread);

src/channel-map.ts

@@ -0,0 +1,32 @@
+import { strict as assert } from "assert";
+
+import { BotUtilities } from "./bot-utilities.js";
+import { typed_channel_id, channel_type_map, Wheatley } from "./wheatley.js";
+
+type keyed_channel_id = typed_channel_id & { key: string };
+
+export function channel_map<const T extends readonly keyed_channel_id[]>(
+    wheatley: Wheatley,
+    ...channel_ids: T
+): { resolve(): Promise<void> } & { [E in T[number] as E["key"]]: channel_type_map[E["type"]] } {
+    const target: Record<string, unknown> = {};
+    let resolved = false;
+    const resolve = async () => {
+        const utilities = new BotUtilities(wheatley);
+        for (const channel_id of channel_ids) {
+            target[channel_id.key] = await utilities.resolve_channel(channel_id);
+        }
+        resolved = true;
+    };
+    return new Proxy(target, {
+        get(obj, prop) {
+            if (prop === "resolve") {
+                return resolve;
+            }
+            if (typeof prop === "string") {
+                assert(resolved, `Channel binding accessed before resolution (key: ${prop})`);
+            }
+            return Reflect.get(obj, prop);
+        },
+    }) as { resolve(): Promise<void> } & { [E in T[number] as E["key"]]: channel_type_map[E["type"]] };
+}

src/modules/tccpp/components/anti-screenshot.ts

@@ -6,9 +6,9 @@ import { delay } from "../../../utils/misc.js";
 import { M } from "../../../utils/debugging-and-logging.js";
 import { colors } from "../../../common.js";
 import { BotComponent } from "../../../bot-component.js";
-import { Wheatley } from "../../../wheatley.js";
 import { CommandSetBuilder } from "../../../command-abstractions/command-set-builder.js";
 import { ButtonInteractionBuilder, BotButton } from "../../../command-abstractions/button.js";
+import { channel_map } from "../../../channel-map.js";
 
 const DISMISS_TIME = 30 * 1000;
 
@@ -27,12 +27,12 @@ function message_might_have_code(message: string) {
 }
 
 export default class AntiScreenshot extends BotComponent {
-    private staff_message_log!: Discord.TextChannel;
+    private channels = channel_map(this.wheatley, this.wheatley.channels.staff_message_log);
 
     private acknowledge_button!: BotButton<[]>;
 
     override async setup(commands: CommandSetBuilder) {
-        this.staff_message_log = await this.utilities.get_channel(this.wheatley.channels.staff_message_log);
+        await this.channels.resolve();
 
         this.acknowledge_button = commands.add(
             new ButtonInteractionBuilder("anti_screenshot_acknowledge").set_handler(
@@ -96,7 +96,7 @@ export default class AntiScreenshot extends BotComponent {
                     name: interaction.user.tag,
                     iconURL: interaction.user.avatarURL()!,
                 });
-            await this.staff_message_log.send({
+            await this.channels.staff_message_log.send({
                 content: "Anti-screenshot message dismissed",
                 embeds: [log_embed],
             });
@@ -146,7 +146,7 @@ export default class AntiScreenshot extends BotComponent {
                     iconURL: starter_message.author.avatarURL()!,
                 })
                 .setDescription(starter_message.content || "<empty>");
-            await this.staff_message_log.send({
+            await this.channels.staff_message_log.send({
                 content: "Anti-screenshot message sent",
                 embeds: [log_embed],
                 files: starter_message.attachments.map(a => a),

src/modules/tccpp/components/anti-self-star.ts

@@ -2,15 +2,21 @@ import * as Discord from "discord.js";
 import { strict as assert } from "assert";
 import { departialize } from "../../../utils/discord.js";
 import { BotComponent } from "../../../bot-component.js";
-import { Wheatley } from "../../../wheatley.js";
 import { has_media } from "./autoreact.js";
 import { M } from "../../../utils/debugging-and-logging.js";
 import { SelfClearingSet } from "../../../utils/containers.js";
 import { MINUTE } from "../../../common.js";
+import { channel_map } from "../../../channel-map.js";
 
 export default class AntiSelfStar extends BotComponent {
+    private channels = channel_map(this.wheatley, this.wheatley.channels.memes);
+
     laughed_at = new SelfClearingSet<string>(5 * MINUTE, MINUTE);
 
+    override async setup() {
+        await this.channels.resolve();
+    }
+
     override async on_reaction_add(
         reaction: Discord.MessageReaction | Discord.PartialMessageReaction,
         user: Discord.User | Discord.PartialUser,
@@ -26,11 +32,7 @@ export default class AntiSelfStar extends BotComponent {
         if (reaction.emoji.name !== "⭐") {
             return;
         }
-        if (
-            message.channelId == this.wheatley.channels.memes.id &&
-            user.id == message.author.id &&
-            has_media(message)
-        ) {
+        if (message.channelId == this.channels.memes.id && user.id == message.author.id && has_media(message)) {
             await this.handle_self_star(await departialize(message));
         }
     }

src/modules/tccpp/components/auto-reply.ts

@@ -3,6 +3,7 @@ import * as Discord from "discord.js";
 import { M } from "../../../utils/debugging-and-logging.js";
 import { DAY, HOUR } from "../../../common.js";
 import { BotComponent } from "../../../bot-component.js";
+import { channel_map } from "../../../channel-map.js";
 
 const LLM_REGEX = /\b(?<!!)llms?\b/gi;
 const MICROSLOP_REGEX = /\b(?<!!)(?<![./])microsoft?\b/gi;
@@ -17,8 +18,14 @@ export default class Autoreply extends BotComponent {
         return true;
     }
 
+    private channels = channel_map(this.wheatley, this.wheatley.channels.bot_spam);
+
     last_reply_time = Date.now() + RATELIMIT_DURATION; // Hedge against restarts
 
+    override async setup() {
+        await this.channels.resolve();
+    }
+
     is_ratelimited() {
         return Date.now() - this.last_reply_time < RATELIMIT_DURATION;
     }
@@ -33,7 +40,7 @@ export default class Autoreply extends BotComponent {
             LLM_REGEX.test(message.content) &&
             !this.is_ratelimited() &&
             Math.random() <= RATELIMIT_PROBABILITY &&
-            message.channel.id !== this.wheatley.channels.bot_spam.id
+            message.channel.id !== this.channels.bot_spam.id
         ) {
             this.last_reply_time = Date.now();
             M.log("firing llm auto-reply");
@@ -48,7 +55,8 @@ export default class Autoreply extends BotComponent {
             MICROSLOP_REGEX.test(message.content) &&
             !this.is_ratelimited() &&
             Math.random() <= RATELIMIT_PROBABILITY &&
-            message.channel.id !== this.wheatley.channels.bot_spam.id
+            message.channel.id !== this.channels.bot_spam.id &&
+            message.author.id !== "1000654924591403108"
         ) {
             this.last_reply_time = Date.now();
             M.log("firing microslop auto-reply");

src/modules/tccpp/components/autoreact.ts

@@ -5,9 +5,9 @@ import { is_media_link_embed } from "../../../utils/discord.js";
 import { M } from "../../../utils/debugging-and-logging.js";
 import { MINUTE, SECOND } from "../../../common.js";
 import { BotComponent } from "../../../bot-component.js";
-import { Wheatley } from "../../../wheatley.js";
 import { SelfClearingMap } from "../../../utils/containers.js";
 import { clear_timeout, set_timeout } from "../../../utils/node.js";
+import { channel_map } from "../../../channel-map.js";
 
 /* Here's a little of an explanation as to why we do this messageSnapshot stuff
  * A forwarded message is empty, however it contains a property messageSnapshot
@@ -40,8 +40,20 @@ function regular_has_media(message: Discord.Message | Discord.PartialMessage): b
 const REACT_TIMEOUT = 90 * SECOND;
 
 export default class Autoreact extends BotComponent {
+    private channels = channel_map(
+        this.wheatley,
+        this.wheatley.channels.introductions,
+        this.wheatley.channels.memes,
+        this.wheatley.channels.server_suggestions,
+        this.wheatley.channels.food,
+    );
+
     react_timeouts = new SelfClearingMap<string, NodeJS.Timeout>(REACT_TIMEOUT);
 
+    override async setup() {
+        await this.channels.resolve();
+    }
+
     override async on_ready() {
         await this.catch_up();
     }
@@ -122,7 +134,7 @@ export default class Autoreact extends BotComponent {
                     this.wheatley.warn("Unable to find emoji nog4g");
                 }
             }
-            if (message.channel.id == this.wheatley.channels.introductions.id) {
+            if (message.channel.id == this.channels.introductions.id) {
                 if (message.member == null) {
                     // TODO: Ping zelis?
                     M.warn("Why??", message);
@@ -132,15 +144,15 @@ export default class Autoreact extends BotComponent {
                     M.log("Waving to new user", message.author.tag, message.author.id, message.url);
                     await message.react("👋");
                 }
-            } else if (message.channel.id == this.wheatley.channels.memes.id && has_media(message)) {
+            } else if (message.channel.id == this.channels.memes.id && has_media(message)) {
                 M.log("Adding star reaction", message.author.tag, message.author.id, message.url);
                 await message.react("⭐");
-            } else if (message.channel.id == this.wheatley.channels.server_suggestions.id) {
+            } else if (message.channel.id == this.channels.server_suggestions.id) {
                 M.log("Adding server suggestion reactions", message.author.tag, message.author.id, message.url);
                 await message.react("👍");
                 await message.react("👎");
                 await message.react("🤷");
-            } else if (message.channel.id == this.wheatley.channels.food.id && has_media(message)) {
+            } else if (message.channel.id == this.channels.food.id && has_media(message)) {
                 const reaction = message.guild!.emojis.cache.find(emoji => emoji.name === "chefskiss");
                 if (reaction !== undefined) {
                     await message.react(reaction);
@@ -152,7 +164,7 @@ export default class Autoreact extends BotComponent {
             // reaction blocked
             if (e instanceof Discord.DiscordAPIError && e.code === 90001) {
                 await message.member?.timeout(1 * MINUTE, "Thou shall not block the bot");
-                if (message.channel.id == this.wheatley.channels.server_suggestions.id) {
+                if (message.channel.id == this.channels.server_suggestions.id) {
                     await message.delete();
                 }
             } else {
@@ -177,7 +189,7 @@ export default class Autoreact extends BotComponent {
         if (new_message.createdTimestamp && Date.now() - new_message.createdTimestamp > 5 * MINUTE) {
             return;
         }
-        if (new_message.channel.id == this.wheatley.channels.memes.id) {
+        if (new_message.channel.id == this.channels.memes.id) {
             const bot_starred = new_message.reactions.cache.get("⭐")?.users.cache.has(this.wheatley.user.id);
             // If we haven't stared (or don't know if we've starred) and the new message has media, star
             if (!bot_starred && has_media(new_message)) {
@@ -204,8 +216,7 @@ export default class Autoreact extends BotComponent {
     }
 
     async catch_up() {
-        const introductions_channel = await this.utilities.get_channel(this.wheatley.channels.introductions);
-        const messages = await introductions_channel.messages.fetch({ limit: 100, cache: false });
+        const messages = await this.channels.introductions.messages.fetch({ limit: 100, cache: false });
         for (const [_, message] of messages) {
             if (await this.is_new_member(message)) {
                 M.log("Waving to new user", message.author.tag, message.author.id, message.url);