import database from "../utils/database.js"; import { log, error as _error } from "../utils/logger.js"; import { prefixCache, aliases, disabledCache, disabledCmdCache, commands } from "../utils/collections.js"; import parseCommand from "../utils/parseCommand.js"; import { clean, cleanMessage } from "../utils/misc.js"; import { upload } from "../utils/tempimages.js"; import { ThreadChannel } from "oceanic.js"; // run when someone sends a message export default async (client, message) => { // ignore other bots if (message.author.bot) return; // don't run command if bot can't send messages let permChannel = message.channel; if (permChannel instanceof ThreadChannel && !permChannel.parent) { try { permChannel = await client.rest.channels.get(message.channel.parentID); } catch { return; } } if (message.guildID && !permChannel.permissionsOf(client.user.id.toString()).has("SEND_MESSAGES")) return; let prefixCandidate; let guildDB; if (message.guildID) { const cachedPrefix = prefixCache.get(message.guildID); if (cachedPrefix) { prefixCandidate = cachedPrefix; } else { guildDB = await database.getGuild(message.guildID); if (!guildDB) { guildDB = await database.fixGuild(message.guildID); } prefixCandidate = guildDB.prefix; prefixCache.set(message.guildID, guildDB.prefix); } } let prefix; let isMention = false; if (message.guildID) { const user = message.guild.members.get(client.user.id); if (message.content.startsWith(user.mention)) { prefix = `${user.mention} `; isMention = true; } else if (message.content.startsWith(`<@${client.user.id}>`)) { // workaround for member.mention not accounting for both mention types prefix = `<@${client.user.id}> `; isMention = true; } else { prefix = prefixCandidate; } } else { prefix = process.env.PREFIX; } // ignore other stuff if (!message.content.startsWith(prefix)) return; // separate commands and args const replace = isMention ? `@${(message.guild ? message.guild.members.get(client.user.id).nick : client.user.username) ?? client.user.username} ` : prefix; const content = cleanMessage(message).substring(replace.length).trim(); const rawContent = message.content.substring(prefix.length).trim(); const preArgs = content.split(/\s+/g); preArgs.shift(); const command = rawContent.split(/\s+/g).shift().toLowerCase(); const parsed = parseCommand(preArgs); const aliased = aliases.get(command); // don't run if message is in a disabled channel if (message.guildID) { const disabled = disabledCache.get(message.guildID); if (disabled) { if (disabled.includes(message.channelID) && command != "channel") return; } else { guildDB = await database.getGuild(message.guildID); disabledCache.set(message.guildID, guildDB.disabled); if (guildDB.disabled.includes(message.channelID) && command !== "channel") return; } const disabledCmds = disabledCmdCache.get(message.guildID); if (disabledCmds) { if (disabledCmds.includes(aliased ?? command)) return; } else { guildDB = await database.getGuild(message.guildID); disabledCmdCache.set(message.guildID, guildDB.disabled_commands ?? guildDB.disabledCommands); if ((guildDB.disabled_commands ?? guildDB.disabledCommands).includes(aliased ?? command)) return; } } // check if command exists and if it's enabled const cmd = commands.get(aliased ?? command); if (!cmd) return; // block certain commands from running in DMs if (!cmd.directAllowed && !message.guildID) return; // actually run the command log("log", `${message.author.username} (${message.author.id}) ran classic command ${command}`); const reference = { messageReference: { channelID: message.channelID, messageID: message.id, guildID: message.guildID ?? undefined, failIfNotExists: false }, allowedMentions: { repliedUser: false } }; try { await database.addCount(aliases.get(command) ?? command); const startTime = new Date(); // eslint-disable-next-line no-unused-vars const commandClass = new cmd(client, { type: "classic", message, args: parsed._, content: message.content.substring(prefix.length).trim().replace(command, "").trim(), specialArgs: (({ _, ...o }) => o)(parsed) }); // we also provide the message content as a parameter for cases where we need more accuracy const result = await commandClass.run(); const endTime = new Date(); if ((endTime - startTime) >= 180000) reference.allowedMentions.repliedUser = true; if (typeof result === "string") { reference.allowedMentions.repliedUser = true; await client.rest.channels.createMessage(message.channelID, Object.assign({ content: result }, reference)); } else if (typeof result === "object") { if (result.contents && result.name) { let fileSize = 8388119; if (message.guildID) { switch (message.guild.premiumTier) { case 2: fileSize = 52428308; break; case 3: fileSize = 104856616; break; } } if (result.contents.length > fileSize) { if (process.env.TEMPDIR && process.env.TEMPDIR !== "") { await upload(client, result, message); } else { await client.rest.channels.createMessage(message.channelID, { content: "The resulting image was more than 8MB in size, so I can't upload it." }); } } else { await client.rest.channels.createMessage(message.channelID, Object.assign({ content: result.text ? result.text : undefined, files: [result] }, reference)); } } else { await client.rest.channels.createMessage(message.channelID, Object.assign(result, reference)); } } } catch (error) { if (error.toString().includes("Request entity too large")) { await client.rest.channels.createMessage(message.channelID, Object.assign({ content: "The resulting file was too large to upload. Try again with a smaller image if possible." }, reference)); } else if (error.toString().includes("Job ended prematurely")) { await client.rest.channels.createMessage(message.channelID, Object.assign({ content: "Something happened to the image servers before I could receive the image. Try running your command again." }, reference)); } else if (error.toString().includes("Timed out")) { await client.rest.channels.createMessage(message.channelID, Object.assign({ content: "The request timed out before I could download that image. Try uploading your image somewhere else or reducing its size." }, reference)); } else { _error(`Error occurred with command message ${message.content}: ${error.stack || error}`); try { let err = error; if (error?.constructor?.name == "Promise") err = await error; await client.rest.channels.createMessage(message.channelID, Object.assign({ content: "Uh oh! I ran into an error while running this command. Please report the content of the attached file at the following link or on the esmBot Support server: ", files: [{ contents: `Message: ${clean(err)}\n\nStack Trace: ${clean(err.stack)}`, name: "error.txt" }] }, reference)); } catch (e) { _error(`While attempting to send the previous error message, another error occurred: ${e.stack || e}`); } } } };