Revert "Merge remote-tracking branch 'upstream/main' into improvements"

This reverts commit 626bc69, reversing
changes made to 21d5eee.

Author: xLuxy

src/bot-utilities.ts

@@ -129,13 +129,13 @@ export class BotUtilities {
     async get_media(message: MessageData | ForwardedMessageData) {
         return [
             ...message.attachments
-                .filter(a => a.contentType?.startsWith("image"))
+                .filter(a => a.contentType?.indexOf("image") == 0)
                 .map(a => ({
                     type: "image",
                     attachment: a,
                 })),
             ...message.attachments
-                .filter(a => a.contentType?.startsWith("video"))
+                .filter(a => a.contentType?.indexOf("video") == 0)
                 .map(a => ({
                     type: "video",
                     attachment: a,
@@ -175,36 +175,55 @@ export class BotUtilities {
         const media = await this.get_media(message);
         const other_embeds = message.embeds.filter(e => !is_media_link_embed(e));
         const attachments: (Discord.Attachment | Discord.AttachmentPayload)[] = [];
-        const other_attachments = message.attachments.filter(
-            a => !(a.contentType?.startsWith("image") || a.contentType?.startsWith("video")),
-        );
-        const images = media.filter(m => m.type === "image");
-        const videos = media.filter(m => m.type === "video");
-        for (const video of videos) {
-            attachments.push(video.attachment);
-        }
-        if (images.length === 1) {
-            const image = images[0];
-            embed.setImage(
-                image.attachment instanceof Discord.Attachment ? image.attachment.url : image.attachment.attachment,
-            );
-        } else if (images.length > 1) {
-            for (const image of images) {
-                attachments.push(image.attachment);
+        const other_attachments: Discord.Attachment[] = message.attachments
+            .map(a => a)
+            .filter(a => !(a.contentType?.indexOf("image") == 0 || a.contentType?.indexOf("video") == 0));
+        let set_primary_image = false;
+        const media_embeds: Discord.EmbedBuilder[] = [];
+        if (media.length > 0) {
+            for (const medium of media) {
+                if (medium.type == "image") {
+                    if (!set_primary_image) {
+                        embed.setImage(
+                            medium.attachment instanceof Discord.Attachment
+                                ? medium.attachment.url
+                                : medium.attachment.attachment,
+                        );
+                        set_primary_image = true;
+                    } else {
+                        media_embeds.push(
+                            new Discord.EmbedBuilder({
+                                image: {
+                                    url:
+                                        medium.attachment instanceof Discord.Attachment
+                                            ? medium.attachment.url
+                                            : medium.attachment.attachment,
+                                },
+                            }),
+                        );
+                    }
+                } else {
+                    // video
+                    attachments.push(medium.attachment);
+                }
             }
         }
-        // Add stickers as attachments
         for (const sticker of message.stickers ?? []) {
             if (sticker.url) {
-                attachments.push({ attachment: sticker.url, name: `${sticker.name}.png` });
+                media_embeds.push(
+                    new Discord.EmbedBuilder({
+                        image: { url: sticker.url },
+                    }),
+                );
             }
         }
         if (options?.no_extra_media_embeds) {
+            media_embeds.splice(0, media_embeds.length);
             other_embeds.splice(0, other_embeds.length);
             attachments.splice(0, attachments.length);
             other_attachments.splice(0, other_attachments.length);
         }
-        const embeds = other_embeds.map(api_embed => new Discord.EmbedBuilder(api_embed));
+        const embeds = [...media_embeds, ...other_embeds.map(api_embed => new Discord.EmbedBuilder(api_embed))];
         const files = [...attachments, ...other_attachments];
         return [embeds, files];
     }
@@ -291,7 +310,7 @@ export class BotUtilities {
         }
         return {
             embeds: [embed, ...extra_embeds],
-            files: attachments.length ? attachments : undefined,
+            files: attachments.length ? undefined : attachments,
         };
     }
 

src/command-abstractions/command-set-builder.ts

@@ -17,12 +17,11 @@ import { Wheatley } from "../wheatley.js";
 const global_context_menu_limit = 5;
 
 export class CommandSetBuilder {
-    private commands: (Discord.SlashCommandBuilder | Discord.ContextMenuCommandBuilder)[] = [];
-    private text_commands: Record<string, BotTextBasedCommand<unknown[]>> = {};
-    private other_commands: Record<string, BaseBotInteraction<unknown[]>> = {};
-    private button_handlers: Record<string, BotButtonHandler<any[]>> = {};
-    private modal_handlers: Record<string, BotModalHandler<any[]>> = {};
-    private pending_text_commands: Map<string, TextBasedCommandBuilder<any, true, any, true>> = new Map();
+    commands: (Discord.SlashCommandBuilder | Discord.ContextMenuCommandBuilder)[] = [];
+    text_commands: Record<string, BotTextBasedCommand<unknown[]>> = {};
+    other_commands: Record<string, BaseBotInteraction<unknown[]>> = {};
+    button_handlers: Record<string, BotButtonHandler<any[]>> = {};
+    modal_handlers: Record<string, BotModalHandler<any[]>> = {};
 
     constructor(readonly wheatley: Wheatley) {}
 
@@ -46,18 +45,12 @@ export class CommandSetBuilder {
             | ButtonInteractionBuilder<T, true>,
     ) {
         if (command instanceof TextBasedCommandBuilder) {
-            const name = command.names[0];
-            const existing = this.pending_text_commands.get(name);
-            if (existing) {
-                assert(
-                    existing.subcommands.length > 0 && command.subcommands.length > 0,
-                    `Cannot merge command "${name}" - both must have subcommands`,
-                );
-                for (const subcommand of command.subcommands) {
-                    existing.add_subcommand(subcommand);
+            for (const descriptor of command.to_command_descriptors(this.wheatley)) {
+                assert(!(descriptor.name in this.text_commands));
+                this.text_commands[descriptor.name] = descriptor;
+                if (descriptor.slash) {
+                    this.register(descriptor.to_slash_command(new Discord.SlashCommandBuilder()));
                 }
-            } else {
-                this.pending_text_commands.set(name, command as TextBasedCommandBuilder<any, true, any, true>);
             }
         } else if (command instanceof ButtonInteractionBuilder) {
             const button_handler = command.build_handler();
@@ -90,14 +83,6 @@ export class CommandSetBuilder {
     }
 
     async finalize(token: string) {
-        for (const command of this.pending_text_commands.values()) {
-            for (const descriptor of command.to_command_descriptors(this.wheatley)) {
-                this.text_commands[descriptor.name] = descriptor;
-                if (descriptor.slash) {
-                    this.register(descriptor.to_slash_command(new Discord.SlashCommandBuilder()));
-                }
-            }
-        }
         try {
             const rest = new REST({ version: "10" }).setToken(token);
             if (this.wheatley.freestanding) {

src/command-handler.ts

@@ -456,11 +456,8 @@ export class CommandHandler {
             }
             // TODO: Notify if errors occur in the handler....
         } catch (e) {
-            if (interaction.isAutocomplete() && e instanceof Discord.DiscordAPIError && e.code === 10062) {
-                M.warn("Autocomplete interaction expired before response could be sent");
-            } else {
-                this.wheatley.critical_error(e);
-            }
+            // TODO....
+            this.wheatley.critical_error(e);
         }
     }
 }

src/modules/wheatley/components/anti-everyone.ts

@@ -40,19 +40,12 @@ export default class AntiEveryone extends BotComponent {
             if (!this.replies.has(message.author)) {
                 this.replies.set(message.author, []);
             }
-            try {
-                const reply = await message.reply({
-                    content: `Did you really just try to ping ${member_count} people?`,
-                });
-                // Store the reply for later deletion, along with the message it was replying to
-                unwrap(this.replies.get(message.author)).push({ reply_to: message.id, reply });
-            } catch (e) {
-                if (e instanceof Discord.DiscordAPIError && e.code === 50035) {
-                    // If the original message was deleted before we could reply, ignore the error
-                } else {
-                    this.wheatley.critical_error(e);
-                }
-            }
+            const reply = await message.reply({
+                content: `Did you really just try to ping ${member_count} people?`,
+            });
+
+            // Store the reply for later deletion, along with the message it was replying to
+            unwrap(this.replies.get(message.author)).push({ reply_to: message.id, reply });
         }
     }
 

src/modules/wheatley/components/anti-executable.ts

@@ -11,11 +11,8 @@ import { Virustotal } from "../../../infra/virustotal.js";
 import Mute from "./moderation/mute.js";
 import { delay, unwrap } from "../../../utils/misc.js";
 import { CommandSetBuilder } from "../../../command-abstractions/command-set-builder.js";
-import { M } from "../../../utils/debugging-and-logging.js";
 
 const ACTION_THRESHOLD = 5;
-const BASE_RETRY_DELAY_MS = 1000;
-const NOT_FOUND_RETRY_DELAY_MS = 3000;
 
 class HTTPError extends Error {
     constructor(
@@ -160,53 +157,21 @@ export default class AntiExecutable extends BotComponent {
         return true;
     }
 
-    private async fetch_with_retry(
-        url: string,
-        options?: { limit?: number; max_retries?: number },
-    ): Promise<Buffer | null> {
-        // Try to fetch, retrying on 5xx failure. If the error is 404, retry once.
-        const { limit, max_retries = 3 } = options ?? {};
-        let attempt = 0;
-        let not_found_retry_used = false;
-
-        while (true) {
+    private async fetch_with_retry(url: string, limit?: number, max_retries = 3): Promise<Buffer> {
+        const base_delay_ms = 1000;
+        for (let attempt = 0; attempt <= max_retries; attempt++) {
             try {
                 return await this.fetch(url, limit);
             } catch (e) {
-                if (e instanceof HTTPError && e.status_code === 404) {
-                    if (not_found_retry_used) {
-                        return null;
-                    }
-                    not_found_retry_used = true;
-                    await delay(NOT_FOUND_RETRY_DELAY_MS);
-                    continue;
-                }
-                if (attempt >= max_retries || !this.is_retryable_error(e)) {
+                const is_last_attempt = attempt === max_retries;
+                if (is_last_attempt || !this.is_retryable_error(e)) {
                     throw e;
                 }
-                await delay(BASE_RETRY_DELAY_MS * Math.pow(2, attempt));
-                attempt++;
-            }
-        }
-    }
-
-    private async fetch_attachment(url: string, message_url: string, limit?: number): Promise<Buffer | null> {
-        try {
-            const buffer = await this.fetch_with_retry(url, { limit });
-            if (buffer === null) {
-                M.info(`HTTP 404 while fetching attachment for message ${message_url}: \`${url}\``);
-            }
-            return buffer;
-        } catch (e) {
-            if (e instanceof HTTPError) {
-                this.wheatley.warn(
-                    `HTTP Error ${e.status_code} while fetching attachment for message ${message_url}: \`${url}\``,
-                );
-            } else {
-                this.wheatley.critical_error(e);
+                const delay_ms = base_delay_ms * Math.pow(2, attempt);
+                await delay(delay_ms);
             }
-            return null;
         }
+        throw new Error("Unreachable");
     }
 
     async virustotal_scan(
@@ -274,10 +239,24 @@ export default class AntiExecutable extends BotComponent {
     ) {
         await Promise.all(
             attachments.map(async attachment => {
-                const buffer = await this.fetch_attachment(attachment.url, message_url);
-                if (buffer !== null) {
-                    await this.virustotal_scan(buffer, flag_message, author, original_message);
+                // download
+                let file_buffer: Buffer;
+                try {
+                    file_buffer = await this.fetch_with_retry(attachment.url);
+                } catch (e) {
+                    if (e instanceof HTTPError) {
+                        this.wheatley.warn(
+                            `HTTP Error ${e.status_code} while fetching attachment for ` +
+                                `message ${message_url}: \`${attachment.url}\``,
+                        );
+                        return;
+                    } else {
+                        this.wheatley.critical_error(e);
+                        return;
+                    }
                 }
+                // virustotal
+                await this.virustotal_scan(file_buffer, flag_message, author, original_message);
             }),
         );
     }
@@ -314,14 +293,24 @@ export default class AntiExecutable extends BotComponent {
             const executables: Discord.Attachment[] = [];
             const archives: Discord.Attachment[] = [];
             for (const [_, attachment] of message.attachments) {
-                const buffer = await this.fetch_attachment(attachment.url, message.url, 512);
-                if (buffer === null) {
-                    return;
-                }
-                if (this.looks_like_executable(buffer)) {
-                    executables.push(attachment);
-                } else if (this.looks_like_archive(buffer)) {
-                    archives.push(attachment);
+                try {
+                    const res = await this.fetch_with_retry(attachment.url, 512);
+                    if (this.looks_like_executable(res)) {
+                        executables.push(attachment);
+                    } else if (this.looks_like_archive(res)) {
+                        archives.push(attachment);
+                    }
+                } catch (e) {
+                    if (e instanceof HTTPError) {
+                        this.wheatley.warn(
+                            `HTTP Error ${e.status_code} while fetching attachment for ` +
+                                `message ${message.url}: \`${attachment.url}\``,
+                        );
+                        return;
+                    } else {
+                        this.wheatley.critical_error(e);
+                        return;
+                    }
                 }
             }
             if (executables.length > 0) {