chore(release): 1.0.0-dev.26 [skip ci]

# @revanced/discord-bot [1.0.0-dev.26](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.25...@revanced/discord-bot@1.0.0-dev.26) (2024-08-15)

### Bug Fixes

* **bots/discord:** correct timer active condition for sticky messages ([96065ff](96065ff175))

apis/websocket/CHANGELOG.md

@@ -1,3 +1,10 @@
+# @revanced/bot-websocket-api [1.0.0-dev.9](https://github.com/revanced/revanced-helper/compare/@revanced/bot-websocket-api@1.0.0-dev.8...@revanced/bot-websocket-api@1.0.0-dev.9) (2024-08-03)
+
+
+### Features
+
+* **apis/websocket:** return `true` for data on a `TrainedMessage` packet ([65add4d](https://github.com/revanced/revanced-helper/commit/65add4dfeed2fa067c2c8e2377f7d01d505ade54))
+
 # @revanced/bot-websocket-api [1.0.0-dev.8](https://github.com/revanced/revanced-helper/compare/@revanced/bot-websocket-api@1.0.0-dev.7...@revanced/bot-websocket-api@1.0.0-dev.8) (2024-07-31)
 
 

apis/websocket/package.json

@@ -2,7 +2,7 @@
   "name": "@revanced/bot-websocket-api",
   "type": "module",
   "private": true,
-  "version": "1.0.0-dev.8",
+  "version": "1.0.0-dev.9",
   "description": "🧦 WebSocket API server for bots assisting ReVanced",
   "main": "dist/index.js",
   "scripts": {

apis/websocket/src/events/trainMessage.ts

@@ -18,7 +18,7 @@ const trainMessageEventHandler: EventHandler<ClientOperation.TrainMessage> = asy
         client.send(
             {
                 op: ServerOperation.TrainedMessage,
-                d: null,
+                d: true,
             },
             nextSeq,
         )

bots/discord/.gitignore

@@ -174,9 +174,6 @@ dist
 # Finder (MacOS) folder config
 .DS_Store
 
-# Config
-config.ts
-
 # DB
 *.db
 *.sqlite

bots/discord/CHANGELOG.md

@@ -1,3 +1,128 @@
+# @revanced/discord-bot [1.0.0-dev.26](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.25...@revanced/discord-bot@1.0.0-dev.26) (2024-08-15)
+
+
+### Bug Fixes
+
+* **bots/discord:** correct timer active condition for sticky messages ([96065ff](https://github.com/revanced/revanced-helper/commit/96065ff17584ff99a56ca5008327863ca5a7852b))
+
+# @revanced/discord-bot [1.0.0-dev.25](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.24...@revanced/discord-bot@1.0.0-dev.25) (2024-08-15)
+
+
+### Bug Fixes
+
+* **bots/discord:** allow access to `context` in `/eval` and await result ([99f65f0](https://github.com/revanced/revanced-helper/commit/99f65f07f5f8830c6e8ea4ae171e986af4d3f1f6))
+
+# @revanced/discord-bot [1.0.0-dev.24](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.23...@revanced/discord-bot@1.0.0-dev.24) (2024-08-14)
+
+
+### Bug Fixes
+
+* **bots/discord:** do not remove unrelated reactions ([031fd26](https://github.com/revanced/revanced-helper/commit/031fd26b2619ecafeff3964e50accacb87de6108))
+
+# @revanced/discord-bot [1.0.0-dev.23](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.22...@revanced/discord-bot@1.0.0-dev.23) (2024-08-13)
+
+
+### Features
+
+* **bots/discord:** add `train` commands ([ee90ef2](https://github.com/revanced/revanced-helper/commit/ee90ef247b4bf2b3c0698606b947116f2dc1b868))
+* **bots/discord:** update to newer command definition framework ([97f2795](https://github.com/revanced/revanced-helper/commit/97f2795df4ede4d12a08193dba453c1bc765a4c2))
+
+# @revanced/discord-bot [1.0.0-dev.22](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.21...@revanced/discord-bot@1.0.0-dev.22) (2024-08-10)
+
+
+### Bug Fixes
+
+* **bots/discord:** parse larger units of durations, fix wrong timestamp in mod embed ([6c8dce0](https://github.com/revanced/revanced-helper/commit/6c8dce059366a6ef85f5b8b1794c056515b9f5b6))
+* **bots/discord:** provide discord token for `reload` command ([dd21a5a](https://github.com/revanced/revanced-helper/commit/dd21a5abad560f3d00b8c58912786d4b6bd520e9))
+
+
+### Features
+
+* **bots/discord:** add code to actually scan text files correctly ([80aeb19](https://github.com/revanced/revanced-helper/commit/80aeb1902063140a2e78cfaed9424e5101ab03f1))
+
+# @revanced/discord-bot [1.0.0-dev.21](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.20...@revanced/discord-bot@1.0.0-dev.21) (2024-08-04)
+
+
+### Bug Fixes
+
+* **bots/discord:** correct sticky messages logic ([de8bef6](https://github.com/revanced/revanced-helper/commit/de8bef6520d53a1299f0478458320a7eb75c5e1d))
+* **bots/discord:** make `/eval` work ([eaa25f2](https://github.com/revanced/revanced-helper/commit/eaa25f2eb58a9e2d25bb98633ad668485e099714))
+* **bots/discord:** some configuration values not applying after running `/reload` ([a976dd2](https://github.com/revanced/revanced-helper/commit/a976dd2accc4b74914651245acde0979c30c92f5))
+
+# @revanced/discord-bot [1.0.0-dev.20](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.19...@revanced/discord-bot@1.0.0-dev.20) (2024-08-03)
+
+
+### Bug Fixes
+
+* **bots/discord:** await when putting entries into db ([4da6175](https://github.com/revanced/revanced-helper/commit/4da6175cf58b1fa6144bdc71ec806766d32c1025))
+
+# @revanced/discord-bot [1.0.0-dev.19](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.18...@revanced/discord-bot@1.0.0-dev.19) (2024-08-03)
+
+
+### Bug Fixes
+
+* **bots/discord:** correct whitelist logic ([49c29be](https://github.com/revanced/revanced-helper/commit/49c29bebfbe348ae4e2cc1b3a83bfa41eb26ccd1))
+
+# @revanced/discord-bot [1.0.0-dev.18](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.17...@revanced/discord-bot@1.0.0-dev.18) (2024-08-03)
+
+
+### Bug Fixes
+
+* **bots/discord:** set the `label` property correctly for message scans ([6d463df](https://github.com/revanced/revanced-helper/commit/6d463df586dee5dd8fe8d6cff1c5316f7809b32a))
+
+# @revanced/discord-bot [1.0.0-dev.17](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.16...@revanced/discord-bot@1.0.0-dev.17) (2024-08-02)
+
+
+### Bug Fixes
+
+* **bots/discord/commands/eval:** evaluate in current context ([5925d90](https://github.com/revanced/revanced-helper/commit/5925d902095acef5f6396ca03583a9cbb0862498))
+* **bots/discord:** send right response for after regexes ([a7688fa](https://github.com/revanced/revanced-helper/commit/a7688fa9b91919a87f74071b502cd0a87cd1c1fa))
+
+
+### Features
+
+* **bots/discord:** update example config file ([bc9951c](https://github.com/revanced/revanced-helper/commit/bc9951c9b5e007c3e1b3076aa0966ccf29bb18bc))
+
+# @revanced/discord-bot [1.0.0-dev.16](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.15...@revanced/discord-bot@1.0.0-dev.16) (2024-08-02)
+
+
+### Bug Fixes
+
+* **bots/discord:** open database as read-write ([c366840](https://github.com/revanced/revanced-helper/commit/c36684091dddf67880505dc459e4334a8a5492f4))
+* **bots/discord:** remove bad text channel checks ([f5939e2](https://github.com/revanced/revanced-helper/commit/f5939e25288fea2022fdeec9085ecb9ffada6111))
+* **bots/discord:** remove redundant footer for response embeds ([412e003](https://github.com/revanced/revanced-helper/commit/412e00317d1eaca23e9c1375e16f94a5f2fa8d86))
+
+
+### Features
+
+* **bots/discord/commands:** add `reload` command ([6875b32](https://github.com/revanced/revanced-helper/commit/6875b32fd0c6ce3034da9dc6c704d425afb26f2e))
+
+# @revanced/discord-bot [1.0.0-dev.15](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.14...@revanced/discord-bot@1.0.0-dev.15) (2024-07-31)
+
+
+### Bug Fixes
+
+* **bots/discord:** import `config` from context ([763ef25](https://github.com/revanced/revanced-helper/commit/763ef253f9d4ff70a8b79969a7f4f41cba7f3c59))
+
+
+### Features
+
+* **bots/discord:** add sticky messages ([bf66155](https://github.com/revanced/revanced-helper/commit/bf661556e131bf0ef24e47f658fbcd701960e312))
+
+# @revanced/discord-bot [1.0.0-dev.14](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.13...@revanced/discord-bot@1.0.0-dev.14) (2024-07-31)
+
+
+### Bug Fixes
+
+* **bots/discord:** always true check causing no messages to be scanned ([98ec37b](https://github.com/revanced/revanced-helper/commit/98ec37b5d18cade85270ab83b0ed0abe41244dd9))
+* other small issues ([bc437a5](https://github.com/revanced/revanced-helper/commit/bc437a5ec7ce1d339094d608e2a61ac5f460c163))
+
+
+### Features
+
+* **bots/discord:** add more options for curing, fix default regex ([1a4ec1e](https://github.com/revanced/revanced-helper/commit/1a4ec1ece80becd9156582cc490f6681cb2a1f39))
+* **bots/discord:** allow admins to bypass permission checks ([620f933](https://github.com/revanced/revanced-helper/commit/620f9339f0737b79d72c66d90ffa42ea3f987710))
+
 # @revanced/discord-bot [1.0.0-dev.13](https://github.com/revanced/revanced-helper/compare/@revanced/discord-bot@1.0.0-dev.12...@revanced/discord-bot@1.0.0-dev.13) (2024-07-30)
 
 

bots/discord/config.js

@@ -11,8 +11,21 @@ export default {
             GUILD_ID_HERE: ['ROLE_ID_HERE'],
         },
     },
+    stickyMessages: {
+        GUILD_ID_HERE: {
+            CHANNEL_ID_HERE: {
+                message: {
+                    content: 'This is a sticky message!',
+                },
+                timeout: 60000,
+                forceSendTimeout: 300000,
+            }
+        }
+    },
     moderation: {
         cure: {
+            minimumNameLength: 3,
+            removeCharactersRegex: /[^a-zA-Z0-9 \-_]/g,
             defaultName: 'Server member',
         },
         roles: ['ROLE_ID_HERE'],
@@ -61,7 +74,11 @@ export default {
                 },
             },
         },
-        allowedAttachmentMimeTypes: ['image/jpeg', 'image/png', 'image/webp'],
+        attachments: {
+            scanAttachments: true,
+            allowedMimeTypes: ['image/jpeg', 'image/png', 'image/webp', 'text/plain'],
+            maxTextFileSize: 512000
+        },
         responses: [
             {
                 filterOverride: {

bots/discord/config.schema.ts

@@ -6,6 +6,7 @@ export type Config = {
         users?: string[]
         roles?: Record<string, string[]>
     }
+    stickyMessages?: Record<string, Record<string, StickyMessageConfig>>
     moderation?: {
         roles: string[]
         cure?: {
@@ -25,7 +26,11 @@ export type Config = {
     messageScan?: {
         scanBots?: boolean
         scanOutsideGuilds?: boolean
-        allowedAttachmentMimeTypes: string[]
+        attachments?: {
+            scanAttachments?: boolean
+            allowedMimeTypes?: string[]
+            maxTextFileSize?: number
+        }
         filter?: {
             whitelist?: Filter
             blacklist?: Filter
@@ -50,6 +55,12 @@ export type Config = {
     }
 }
 
+export type StickyMessageConfig = {
+    timeout: number
+    forceSendTimeout?: number
+    message: BaseMessageOptions
+}
+
 export type RolePresetConfig = {
     give: string[]
     take: string[]
@@ -62,7 +73,7 @@ export type ConfigMessageScanResponse = {
     }
     filterOverride?: NonNullable<Config['messageScan']>['filter']
     response: ConfigMessageScanResponseMessage | null
-    replyToReplied?: boolean
+    respondToReply?: boolean
 }
 
 export type ConfigMessageScanResponseLabelConfig = {

bots/discord/package.json

@@ -2,16 +2,15 @@
   "name": "@revanced/discord-bot",
   "type": "module",
   "private": true,
-  "version": "1.0.0-dev.13",
+  "version": "1.0.0-dev.26",
   "description": "🤖 Discord bot assisting ReVanced",
   "main": "src/index.ts",
   "scripts": {
-    "register": "bun run scripts/reload-slash-commands.ts",
     "start": "bun prepare && bun run src/index.ts",
     "dev": "bun prepare && bun --watch src/index.ts",
     "build": "bun prepare && bun run scripts/build.ts",
     "watch": "bun dev",
-    "prepare": "bun run scripts/generate-indexes.ts && bunx drizzle-kit generate --name=schema"
+    "prepare": "bun run scripts/generate-indexes.ts && bunx --bun drizzle-kit generate --name=schema"
   },
   "repository": {
     "type": "git",

bots/discord/src/classes/Command.ts

@@ -1,76 +1,145 @@
-import { ApplicationCommandOptionType } from 'discord.js'
+import { ApplicationCommandOptionType, ApplicationCommandType } from 'discord.js'
+import { isAdmin } from '../utils/discord/permissions'
 
-import { createErrorEmbed } from '$/utils/discord/embeds'
-import { isAdmin } from '$/utils/discord/permissions'
-
-import { config } from '../context'
 import CommandError, { CommandErrorType } from './CommandError'
 
-import type { Filter } from 'config.schema'
 import type {
     APIApplicationCommandChannelOption,
     CacheType,
     Channel,
     ChatInputCommandInteraction,
+    CommandInteraction,
     CommandInteractionOption,
     GuildMember,
     Message,
+    MessageContextMenuCommandInteraction,
+    RESTPostAPIApplicationCommandsJSONBody,
     RESTPostAPIChatInputApplicationCommandsJSONBody,
     Role,
     User,
+    UserContextMenuCommandInteraction,
+    UserResolvable,
 } from 'discord.js'
+import { config } from '../context'
+
+export enum CommandType {
+    ChatGlobal = 1,
+    ChatGuild,
+    ContextMenuUser,
+    ContextMenuMessage,
+    ContextMenuGuildMessage,
+    ContextMenuGuildMember,
+}
 
 export default class Command<
-    Global extends boolean = false,
+    const Type extends CommandType = CommandType.ChatGuild,
-    Options extends CommandOptionsOptions | undefined = undefined,
+    const Options extends If<IsContextMenu<Type>, undefined, CommandOptionsOptions | undefined> = undefined,
-    AllowMessageCommand extends boolean = false,
+    const AllowMessageCommand extends If<IsContextMenu<Type>, false, boolean> = false,
 > {
     name: string
     description: string
     requirements?: CommandRequirements
     options?: Options
-    global?: Global
+    type: Type
-    #execute: CommandExecuteFunction<Global, Options, AllowMessageCommand>
+    allowMessageCommand: AllowMessageCommand
+    #execute: CommandExecuteFunction<Type, Options, AllowMessageCommand>
 
     static OptionType = ApplicationCommandOptionType
+    static Type = CommandType
 
     constructor({
         name,
         description,
         requirements,
         options,
-        global,
+        type,
+        allowMessageCommand,
         execute,
-    }: CommandOptions<Global, Options, AllowMessageCommand>) {
+    }: CommandOptions<Type, Options, AllowMessageCommand>) {
         this.name = name
-        this.description = description
+        this.description = description!
         this.requirements = requirements
         this.options = options
-        this.global = global
+        // @ts-expect-error: Default is `CommandType.GuildOnly`, it makes sense
+        this.type = type ?? CommandType.ChatGuild
+        // @ts-expect-error: Default is `false`, it makes sense
+        this.allowMessageCommand = allowMessageCommand ?? false
         this.#execute = execute
     }
 
+    isGuildSpecific(): this is Command<
+        CommandType.ChatGuild | CommandType.ContextMenuGuildMember | CommandType.ContextMenuGuildMessage,
+        Options,
+        AllowMessageCommand
+    > {
+        return [
+            CommandType.ChatGuild,
+            CommandType.ContextMenuGuildMessage,
+            CommandType.ContextMenuGuildMember,
+        ].includes(this.type)
+    }
+
+    isContextMenuSpecific(): this is Command<
+        | CommandType.ContextMenuGuildMessage
+        | CommandType.ContextMenuGuildMember
+        | CommandType.ContextMenuUser
+        | CommandType.ContextMenuMessage,
+        undefined,
+        false
+    > {
+        return [
+            CommandType.ContextMenuMessage,
+            CommandType.ContextMenuUser,
+            CommandType.ContextMenuGuildMessage,
+            CommandType.ContextMenuGuildMember,
+        ].includes(this.type)
+    }
+
+    isGuildContextMenuSpecific(): this is Command<
+        CommandType.ContextMenuGuildMessage | CommandType.ContextMenuGuildMember,
+        undefined,
+        false
+    > {
+        return [CommandType.ContextMenuGuildMessage, CommandType.ContextMenuGuildMember].includes(this.type)
+    }
+
+    async onContextMenuInteraction(
+        context: typeof import('../context'),
+        interaction: If<
+            Extends<Type, CommandType.ContextMenuGuildMessage>,
+            MessageContextMenuCommandInteraction<ToCacheType<Type>>,
+            UserContextMenuCommandInteraction<ToCacheType<Type>>
+        >,
+    ): Promise<unknown> {
+        if (!this.isGuildSpecific() && !interaction.inGuild())
+            throw new CommandError(CommandErrorType.InteractionNotInGuild)
+
+        const executor = await this.#fetchInteractionExecutor(interaction)
+        const target =
+            this.type === CommandType.ContextMenuGuildMember
+                ? this.isGuildSpecific()
+                    ? fetchMember(interaction as CommandInteraction<'raw' | 'cached'>, interaction.targetId)
+                    : interaction.client.users.fetch(interaction.targetId)
+                : interaction.channel?.messages.fetch(interaction.targetId)
+
+        if (!target) throw new CommandError(CommandErrorType.FetchManagerNotFound)
+
+        // @ts-expect-error: Type mismatch (again!) because TypeScript is not smart enough
+        return await this.#execute({ ...context, executor, target }, interaction, undefined)
+    }
+
     async onMessage(
         context: typeof import('../context'),
-        msg: Message<If<Global, false, true>>,
+        msg: Message<IsGuildSpecific<Type>>,
         args: CommandArguments,
     ): Promise<unknown> {
-        if (!this.global && !msg.inGuild())
+        if (!this.allowMessageCommand) return
-            return await msg.reply({
+        if (!this.isGuildSpecific() && !msg.guildId) throw new CommandError(CommandErrorType.InteractionNotInGuild)
-                embeds: [createErrorEmbed('Cannot run this command', 'This command can only be used in a server.')],
-            })
 
-        const executor = this.global ? msg.author : await msg.guild?.members.fetch(msg.author.id)!
+        const executor = this.isGuildSpecific()
-
+            ? await msg.guild?.members.fetch(msg.author)!
-        if (!(await this.canExecute(executor, msg.channelId)))
+            : await msg.client.users.fetch(msg.author)
-            return await msg.reply({
+        if (!(await this.canExecute(executor))) throw new CommandError(CommandErrorType.RequirementsNotMet)
-                embeds: [
-                    createErrorEmbed(
-                        'Cannot run this command',
-                        'You do not meet the requirements to run this command.',
-                    ),
-                ],
-            })
 
         const options = this.options
             ? ((await this.#resolveMessageOptions(msg, this.options, args)) as CommandExecuteFunctionOptionsParameter<
@@ -120,14 +189,18 @@ export default class Command<
                     `Invalid type for argument **${name}**.${argExplainationString}\n\nExpected type: **${expectedType}**\nGot type: **${ApplicationCommandOptionType[arg.type]}**${choicesString}`,
                 )
 
-            if ('choices' in option && option.choices && !option.choices.some(({ value }) => value === arg))
+            const argValue = typeof arg === 'string' ? arg : arg?.id
+
+            if (
+                'choices' in option &&
+                option.choices &&
+                !option.choices.some(({ value }) => value === (typeof value === 'number' ? Number(argValue) : argValue))
+            )
                 throw new CommandError(
                     CommandErrorType.InvalidArgument,
-                    `Invalid choice for argument **${name}**.\n${argExplainationString}\n\n${choicesString}\n`,
+                    `Invalid choice for argument **${name}**.\n${argExplainationString}${choicesString}\n`,
                 )
 
-            const argValue = typeof arg === 'string' ? arg : arg?.id
-
             if (argValue && arg) {
                 if (isSubcommandLikeOption) {
                     const [subcommandName, subcommandOption] = iterableOptions.find(([name]) => name === argValue)!
@@ -142,6 +215,16 @@ export default class Command<
                     break
                 }
 
+                if (
+                    type === ApplicationCommandOptionType.String &&
+                    ((typeof option.minLength === 'number' && argValue.length < option.minLength) ||
+                        (typeof option.maxLength === 'number' && argValue.length > option.maxLength))
+                )
+                    throw new CommandError(
+                        CommandErrorType.InvalidArgument,
+                        `Invalid string length for argument **${name}**.\nLengths allowed: ${option.minLength ?? '(any)'} - ${option.maxLength ?? '(any)'}.${argExplainationString}`,
+                    )
+
                 if (
                     (type === ApplicationCommandOptionType.Channel ||
                         type === ApplicationCommandOptionType.User ||
@@ -153,14 +236,21 @@ export default class Command<
                         `Malformed ID for argument **${name}**.${argExplainationString}`,
                     )
 
-                if (
+                if (type === ApplicationCommandOptionType.Number || type === ApplicationCommandOptionType.Integer) {
-                    (type === ApplicationCommandOptionType.Number || type === ApplicationCommandOptionType.Integer) &&
+                    if (Number.isNaN(Number(argValue)))
-                    Number.isNaN(Number(argValue))
+                        throw new CommandError(
-                ) {
+                            CommandErrorType.InvalidArgument,
-                    throw new CommandError(
+                            `Invalid number for argument **${name}**.${argExplainationString}`,
-                        CommandErrorType.InvalidArgument,
+                        )
-                        `Invalid number for argument **${name}**.${argExplainationString}`,
+
+                    if (
+                        (typeof option.min === 'number' && Number(argValue) < option.min) ||
+                        (typeof option.max === 'number' && Number(argValue) > option.max)
                     )
+                        throw new CommandError(
+                            CommandErrorType.InvalidArgument,
+                            `Number out of range for argument **${name}**.\nRange allowed: ${option.min ?? '(any)'} - ${option.max ?? '(any)'}.${argExplainationString}`,
+                        )
                 }
 
                 if (
@@ -177,7 +267,7 @@ export default class Command<
                     type === ApplicationCommandOptionType.Number || type === ApplicationCommandOptionType.Integer
                         ? Number(argValue)
                         : type === ApplicationCommandOptionType.Boolean
-                          ? argValue[0] === 't' || argValue[0] === 'y'
+                          ? ['t', 'y', 'yes', 'true'].some(value => value === argValue.toLowerCase())
                           : type === ApplicationCommandOptionType.Channel
                             ? await msg.client.channels.fetch(argValue)
                             : type === ApplicationCommandOptionType.User
@@ -191,44 +281,27 @@ export default class Command<
         return _options
     }
 
+    #fetchInteractionExecutor(interaction: CommandInteraction) {
+        return this.isGuildSpecific()
+            ? fetchMember(interaction as CommandInteraction<'raw' | 'cached'>)
+            : fetchUser(interaction)
+    }
+
     async onInteraction(
         context: typeof import('../context'),
         interaction: ChatInputCommandInteraction,
     ): Promise<unknown> {
-        const { logger } = context
+        if (interaction.commandName !== this.name)
+            throw new CommandError(
+                CommandErrorType.InteractionDataMismatch,
+                'The interaction command name does not match the expected command name.',
+            )
 
-        if (interaction.commandName !== this.name) {
+        if (!this.isGuildSpecific() && !interaction.inGuild())
-            logger.warn(`Command name mismatch, expected ${this.name}, but got ${interaction.commandName}!`)
+            throw new CommandError(CommandErrorType.InteractionNotInGuild)
-            return await interaction.reply({
-                embeds: [
-                    createErrorEmbed(
-                        'Internal command name mismatch',
-                        'The interaction command name does not match the expected command name.',
-                    ),
-                ],
-            })
-        }
 
-        if (!this.global && !interaction.inGuild()) {
+        const executor = await this.#fetchInteractionExecutor(interaction)
-            logger.error(`Command ${this.name} cannot be run in DMs, but was registered as global`)
+        if (!(await this.canExecute(executor))) throw new CommandError(CommandErrorType.RequirementsNotMet)
-            return await interaction.reply({
-                embeds: [createErrorEmbed('Cannot run this command', 'This command can only be used in a server.')],
-                ephemeral: true,
-            })
-        }
-
-        const executor = this.global ? interaction.user : await interaction.guild?.members.fetch(interaction.user.id)!
-
-        if (!(await this.canExecute(executor, interaction.channelId)))
-            return await interaction.reply({
-                embeds: [
-                    createErrorEmbed(
-                        'Cannot run this command',
-                        'You do not meet the requirements to run this command.',
-                    ),
-                ],
-                ephemeral: true,
-            })
 
         const options = this.options
             ? ((await this.#resolveInteractionOptions(interaction)) as CommandExecuteFunctionOptionsParameter<
@@ -237,14 +310,10 @@ export default class Command<
             : undefined
 
         if (options === null)
-            return await interaction.reply({
+            throw new CommandError(
-                embeds: [
+                CommandErrorType.InteractionDataMismatch,
-                    createErrorEmbed(
+                'The registered interaction command option type does not match the expected command option type.',
-                        'Internal command option type mismatch',
+            )
-                        'The interaction command option type does not match the expected command option type.',
-                    ),
-                ],
-            })
 
         // @ts-expect-error: Type mismatch (again!) because TypeScript is not smart enough
         return await this.#execute({ ...context, executor }, interaction, options)
@@ -288,7 +357,7 @@ export default class Command<
         return _options
     }
 
-    async canExecute(executor: User | GuildMember, channelId: string): Promise<boolean> {
+    async canExecute(executor: User | GuildMember): Promise<boolean> {
         if (!this.requirements) return false
 
         const isExecutorAdmin = isAdmin(executor)
@@ -296,7 +365,6 @@ export default class Command<
 
         const {
             adminOnly,
-            channels,
             roles,
             permissions,
             users,
@@ -305,16 +373,23 @@ export default class Command<
             memberRequirementsForUsers = 'pass',
         } = this.requirements
 
-        const member = this.global ? null : (executor as GuildMember)
+        const member = this.isGuildSpecific() ? null : (executor as GuildMember)
-        const bDefCond = defaultCondition !== 'fail'
+        const boolDefaultCondition = defaultCondition !== 'fail'
-        const bMemReqForUsers = memberRequirementsForUsers !== 'fail'
+        const boolMemberRequirementsForUsers = memberRequirementsForUsers !== 'fail'
 
         const conditions = [
-            adminOnly ? isExecutorAdmin : bDefCond,
+            adminOnly ? isExecutorAdmin : boolDefaultCondition,
-            channels ? channels.includes(channelId) : bDefCond,
+            users ? users.includes(executor.id) : boolDefaultCondition,
-            member ? (roles ? roles.some(role => member.roles.cache.has(role)) : bDefCond) : bMemReqForUsers,
+            member
-            member ? (permissions ? member.permissions.has(permissions) : bDefCond) : bMemReqForUsers,
+                ? roles
-            users ? users.includes(executor.id) : bDefCond,
+                    ? roles.some(role => member.roles.cache.has(role))
+                    : boolDefaultCondition
+                : boolMemberRequirementsForUsers,
+            member
+                ? permissions
+                    ? member.permissions.has(permissions)
+                    : boolDefaultCondition
+                : boolMemberRequirementsForUsers,
         ]
 
         if (mode === 'all' && conditions.some(condition => !condition)) return false
@@ -323,14 +398,27 @@ export default class Command<
         return true
     }
 
-    get json(): RESTPostAPIChatInputApplicationCommandsJSONBody & { contexts: Array<0 | 1 | 2> } {
+    get json(): RESTPostAPIApplicationCommandsJSONBody {
-        return {
+        // @ts-expect-error: I hate union types in TypeScript
+        const base: RESTPostAPIApplicationCommandsJSONBody = {
             name: this.name,
+            type:
+                this.type === CommandType.ContextMenuGuildMessage || this.type === CommandType.ContextMenuMessage
+                    ? ApplicationCommandType.Message
+                    : this.type === CommandType.ContextMenuGuildMember || this.type === CommandType.ContextMenuUser
+                      ? ApplicationCommandType.User
+                      : ApplicationCommandType.ChatInput,
+        }
+
+        if (this.isContextMenuSpecific()) return base
+
+        return {
+            ...base,
             description: this.description,
             options: this.options ? this.#transformOptions(this.options) : undefined,
             // https://discord.com/developers/docs/interactions/receiving-and-responding#interaction-object-interaction-context-types
-            contexts: this.global ? [0] : [0, 1],
+            contexts: this.isGuildSpecific() ? [0] : [0, 1, 2],
-        }
+        } as RESTPostAPIChatInputApplicationCommandsJSONBody & { contexts: Array<0 | 1 | 2> }
     }
 
     #transformOptions(optionsObject: Record<string, CommandOption>) {
@@ -377,8 +465,8 @@ export default class Command<
 export class ModerationCommand<
     Options extends CommandOptionsOptions,
     AllowMessageCommand extends boolean = true,
-> extends Command<false, Options, AllowMessageCommand> {
+> extends Command<CommandType.ChatGuild, Options, AllowMessageCommand> {
-    constructor(options: ExtendedCommandOptions<false, Options, AllowMessageCommand>) {
+    constructor(options: ExtendedCommandOptions<CommandType.ChatGuild, Options, AllowMessageCommand>) {
         super({
             ...options,
             requirements: {
@@ -388,17 +476,16 @@ export class ModerationCommand<
             },
             // @ts-expect-error: No thanks
             allowMessageCommand: options.allowMessageCommand ?? true,
-            global: false,
+            type: CommandType.ChatGuild,
         })
     }
 }
 
-export class AdminCommand<Options extends CommandOptionsOptions, AllowMessageCommand extends boolean> extends Command<
+export class AdminCommand<
-    true,
+    Options extends CommandOptionsOptions,
-    Options,
+    AllowMessageCommand extends boolean = true,
-    AllowMessageCommand
+> extends Command<CommandType.ChatGlobal, Options, AllowMessageCommand> {
-> {
+    constructor(options: ExtendedCommandOptions<CommandType.ChatGlobal, Options, AllowMessageCommand>) {
-    constructor(options: ExtendedCommandOptions<true, Options, AllowMessageCommand>) {
         super({
             ...options,
             requirements: {
@@ -406,38 +493,52 @@ export class AdminCommand<Options extends CommandOptionsOptions, AllowMessageCom
                 adminOnly: true,
                 defaultCondition: 'pass',
             },
-            global: true,
+            allowMessageCommand: options.allowMessageCommand ?? (true as AllowMessageCommand),
+            type: CommandType.ChatGlobal,
         })
     }
 }
 
+const fetchMember = async (
+    interaction: CommandInteraction<'raw' | 'cached'>,
+    source: UserResolvable = interaction.user,
+    manager = interaction.guild?.members,
+) => {
+    const _manager = manager ?? (await interaction.client.guilds.fetch(interaction.guildId).then(it => it.members))
+    if (!_manager) throw new CommandError(CommandErrorType.FetchManagerNotFound, 'Cannot fetch member.')
+    return await _manager.fetch(source)
+}
+
+const fetchUser = (interaction: CommandInteraction, source: UserResolvable = interaction.user) => {
+    return interaction.client.users.fetch(source)
+}
+
 /* TODO: 
     APIApplicationCommandAttachmentOption
     APIApplicationCommandMentionableOption
     APIApplicationCommandRoleOption
 */
 
-export interface CommandOptions<
+export type CommandOptions<
-    Global extends boolean,
+    Type extends CommandType,
     Options extends CommandOptionsOptions | undefined,
     AllowMessageCommand extends boolean,
-> {
+> = {
     name: string
-    description: string
     requirements?: CommandRequirements
     options?: Options
-    execute: CommandExecuteFunction<Global, Options, AllowMessageCommand>
+    execute: CommandExecuteFunction<Type, Options, AllowMessageCommand>
-    global?: Global
+    type?: Type
     allowMessageCommand?: AllowMessageCommand
-}
+} & If<IsContextMenu<Type>, { description?: never }, { description: string }>
 
 export type CommandArguments = Array<string | CommandSpecialArgument>
-
 export type CommandSpecialArgument = {
     type: (typeof CommandSpecialArgumentType)[keyof typeof CommandSpecialArgumentType]
     id: string
 }
 
+//! If things ever get minified, this will most likely break property access via string names
 export const CommandSpecialArgumentType = {
     Channel: ApplicationCommandOptionType.Channel,
     Role: ApplicationCommandOptionType.Role,
@@ -445,31 +546,56 @@ export const CommandSpecialArgumentType = {
 }
 
 type ExtendedCommandOptions<
-    Global extends boolean,
+    Type extends CommandType,
     Options extends CommandOptionsOptions,
     AllowMessageCommand extends boolean,
-> = Omit<CommandOptions<Global, Options, AllowMessageCommand>, 'global'> & {
+> = Omit<CommandOptions<Type, Options, AllowMessageCommand>, 'type'> & {
-    requirements?: Omit<CommandOptions<false, Options, AllowMessageCommand>['requirements'], 'defaultCondition'>
+    requirements?: Omit<CommandOptions<Type, Options, AllowMessageCommand>['requirements'], 'defaultCondition'>
 }
 
 export type CommandOptionsOptions = Record<string, CommandOption>
 
+type ToCacheType<Type extends CommandType> = If<IsGuildSpecific<Type>, 'raw' | 'cached', CacheType>
+
 type CommandExecuteFunction<
-    Global extends boolean,
+    Type extends CommandType,
     Options extends CommandOptionsOptions | undefined,
     AllowMessageCommand extends boolean,
 > = (
-    context: CommandContext<Global>,
+    context: CommandContext<Type>,
     trigger: If<
         AllowMessageCommand,
-        Message<InvertBoolean<Global>> | ChatInputCommandInteraction<If<Global, CacheType, 'raw' | 'cached'>>,
+        Message<IsGuildSpecific<Type>> | CommandTypeToInteractionMap<ToCacheType<Type>>[Type],
-        ChatInputCommandInteraction<If<Global, CacheType, 'raw' | 'cached'>>
+        CommandTypeToInteractionMap<ToCacheType<Type>>[Type]
     >,
     options: Options extends CommandOptionsOptions ? CommandExecuteFunctionOptionsParameter<Options> : never,
 ) => Promise<unknown> | unknown
 
+type CommandTypeToInteractionMap<CT extends CacheType> = {
+    [CommandType.ChatGlobal]: ChatInputCommandInteraction<CT>
+    [CommandType.ChatGuild]: ChatInputCommandInteraction<CT>
+    [CommandType.ContextMenuUser]: UserContextMenuCommandInteraction<CT>
+    [CommandType.ContextMenuMessage]: MessageContextMenuCommandInteraction<CT>
+    [CommandType.ContextMenuGuildMessage]: MessageContextMenuCommandInteraction<CT>
+    [CommandType.ContextMenuGuildMember]: MessageContextMenuCommandInteraction<CT>
+}
+
+type IsContextMenu<Type extends CommandType> = Extends<
+    Type,
+    | CommandType.ContextMenuGuildMessage
+    | CommandType.ContextMenuGuildMember
+    | CommandType.ContextMenuMessage
+    | CommandType.ContextMenuUser
+>
+
+type IsGuildSpecific<Type extends CommandType> = Extends<
+    Type,
+    CommandType.ChatGuild | CommandType.ContextMenuGuildMember | CommandType.ContextMenuGuildMessage
+>
+
+type Extends<T, U> = T extends U ? true : false
 type If<T extends boolean | undefined, U, V> = T extends true ? U : V
-type InvertBoolean<T extends boolean> = If<T, false, true>
+// type InvertBoolean<T extends boolean> = If<T, false, true>
 
 type CommandExecuteFunctionOptionsParameter<Options extends CommandOptionsOptions> = {
     [K in keyof Options]: Options[K]['type'] extends
@@ -484,8 +610,13 @@ type CommandExecuteFunctionOptionsParameter<Options extends CommandOptionsOption
           >
 }
 
-type CommandContext<Global extends boolean> = typeof import('../context') & {
+type CommandContext<Type extends CommandType> = typeof import('../context') & {
-    executor: CommandExecutor<Global>
+    executor: CommandExecutor<Type>
+    target: If<
+        Extends<Type, CommandType.ContextMenuGuildMember>,
+        GuildMember,
+        If<Extends<Type, CommandType.ContextMenuGuildMessage>, Message<true>, never>
+    >
 }
 
 type CommandOptionValueMap = {
@@ -511,7 +642,7 @@ type CommandOption =
     | CommandSubcommandOption
     | CommandSubcommandGroupOption
 
-type CommandExecutor<Global extends boolean> = If<Global, User, GuildMember>
+type CommandExecutor<Type extends CommandType> = If<IsGuildSpecific<Type>, GuildMember, User>
 
 type CommandOptionBase<Type extends ApplicationCommandOptionType> = {
     type: Type
@@ -585,10 +716,12 @@ interface CommandSubcommandLikeOption<
 type CommandSubcommandOption = CommandSubcommandLikeOption<ApplicationCommandOptionType.Subcommand>
 type CommandSubcommandGroupOption = CommandSubcommandLikeOption<ApplicationCommandOptionType.SubcommandGroup>
 
-export type CommandRequirements = Filter & {
+export type CommandRequirements = {
-    mode?: 'all' | 'any'
+    users?: string[]
-    adminOnly?: boolean
+    roles?: string[]
     permissions?: bigint
+    adminOnly?: boolean
     defaultCondition?: 'fail' | 'pass'
-    memberRequirementsForUsers?: 'pass' | 'fail'
+    memberRequirementsForUsers?: 'fail' | 'pass'
+    mode?: 'all' | 'any'
 }

bots/discord/src/classes/CommandError.ts

@@ -1,9 +1,9 @@
-import { createErrorEmbed } from '$/utils/discord/embeds'
+import { createErrorEmbed } from '../utils/discord/embeds'
 
 export default class CommandError extends Error {
     type: CommandErrorType
 
-    constructor(type: CommandErrorType, message?: string) {
+    constructor(type: CommandErrorType, message: string = ErrorMessageMap[type]) {
         super(message)
         this.name = 'CommandError'
         this.type = type
@@ -15,19 +15,34 @@ export default class CommandError extends Error {
 }
 
 export enum CommandErrorType {
-    Generic,
+    Generic = 1,
+    InteractionNotInGuild,
+    InteractionDataMismatch,
+    FetchManagerNotFound,
+    FetchNotFound,
+    RequirementsNotMet = 100,
     MissingArgument,
     InvalidArgument,
-    InvalidUser,
-    InvalidChannel,
-    InvalidDuration,
 }
 
 const ErrorTitleMap: Record<CommandErrorType, string> = {
     [CommandErrorType.Generic]: 'An exception was thrown',
+    [CommandErrorType.InteractionNotInGuild]: 'This command can only be used in servers',
+    [CommandErrorType.InteractionDataMismatch]: 'Command data mismatch',
+    [CommandErrorType.FetchManagerNotFound]: 'Cannot fetch data (manager not found)',
+    [CommandErrorType.FetchNotFound]: 'Cannot fetch data (source not found)',
+    [CommandErrorType.RequirementsNotMet]: 'Command requirements not met',
     [CommandErrorType.MissingArgument]: 'Missing argument',
     [CommandErrorType.InvalidArgument]: 'Invalid argument',
-    [CommandErrorType.InvalidUser]: 'Invalid user',
+}
-    [CommandErrorType.InvalidChannel]: 'Invalid channel',
+
-    [CommandErrorType.InvalidDuration]: 'Invalid duration',
+const ErrorMessageMap: Record<CommandErrorType, string> = {
+    [CommandErrorType.Generic]: 'An generic exception was thrown.',
+    [CommandErrorType.InteractionNotInGuild]: 'This command can only be used in servers.',
+    [CommandErrorType.InteractionDataMismatch]: 'Interaction command data does not match the expected command data.',
+    [CommandErrorType.FetchManagerNotFound]: 'Cannot fetch required data.',
+    [CommandErrorType.FetchNotFound]: 'Cannot fetch target.',
+    [CommandErrorType.RequirementsNotMet]: 'You do not meet the requirements to use this command.',
+    [CommandErrorType.MissingArgument]: 'You are missing a required argument.',
+    [CommandErrorType.InvalidArgument]: 'You provided an invalid argument.',
 }

bots/discord/src/commands/admin/eval.ts

@@ -1,5 +1,4 @@
 import { inspect } from 'util'
-import { runInNewContext } from 'vm'
 import { ApplicationCommandOptionType } from 'discord.js'
 
 import { AdminCommand } from '$/classes/Command'
@@ -21,12 +20,22 @@ export default new AdminCommand({
         },
     },
     async execute(context, trigger, { code, 'show-hidden': showHidden }) {
+        // So it doesn't show up as unused, and we can use it in `code`
+        context
+
         await trigger.reply({
             ephemeral: true,
             embeds: [
                 createSuccessEmbed('Evaluate', `\`\`\`js\n${code}\`\`\``).addFields({
                     name: 'Result',
-                    value: `\`\`\`js\n${inspect(runInNewContext(code, { client: trigger.client, context, trigger }), { depth: 1, showHidden, getters: true, numericSeparator: true, showProxy: true })}\`\`\``,
+                    // biome-ignore lint/security/noGlobalEval: This is fine as it's an admin command
+                    value: `\`\`\`js\n${inspect(await eval(code), {
+                        depth: 1,
+                        showHidden,
+                        getters: true,
+                        numericSeparator: true,
+                        showProxy: true,
+                    })}\`\`\``,
                 }),
             ],
         })

bots/discord/src/commands/admin/reload.ts

@@ -0,0 +1,37 @@
+import { AdminCommand } from '$/classes/Command'
+import { join, dirname } from 'path'
+
+import type { Config } from 'config.schema'
+
+export default new AdminCommand({
+    name: 'reload',
+    description: 'Reload configuration',
+    async execute(context, trigger) {
+        const { api, logger, discord } = context
+        context.config = ((await import(join(dirname(Bun.main), '..', 'config.js'))) as { default: Config }).default
+
+        if ('deferReply' in trigger) await trigger.deferReply({ ephemeral: true })
+
+        logger.info('Reinitializing API client to reload configuration...')
+        await api.client.ws.setOptions(
+            {
+                url: context.config.api.url,
+            },
+            false,
+        )
+        api.intentionallyDisconnecting = true
+        api.client.disconnect(true)
+        api.disconnectCount = 0
+        api.intentionallyDisconnecting = false
+        await api.client.connect()
+
+        logger.info('Reinitializing Discord client to reload configuration...')
+        await discord.client.destroy()
+        // discord.client.token only gets set whenever a new Client is intialized
+        // so that's why we need to provide the token here :/
+        await discord.client.login(process.env['DISCORD_TOKEN'])
+
+        // @ts-expect-error: TypeScript dum
+        await trigger[('deferReply' in trigger ? 'editReply' : 'reply')]({ content: 'Reloaded configuration' })
+    },
+})

bots/discord/src/commands/admin/slash-commands.ts

@@ -42,7 +42,7 @@ export default new AdminCommand({
 
         const { global: globalCommands, guild: guildCommands } = Object.groupBy(
             Object.values(context.discord.commands),
-            cmd => (cmd.global ? 'global' : 'guild'),
+            cmd => (cmd.isGuildSpecific() ? 'guild' : 'global'),
         )
 
         const {

bots/discord/src/commands/fun/coinflip.ts

@@ -6,7 +6,7 @@ import { applyCommonEmbedStyles } from '$/utils/discord/embeds'
 export default new Command({
     name: 'coinflip',
     description: 'Do a coinflip!',
-    global: true,
+    type: Command.Type.ChatGlobal,
     requirements: {
         defaultCondition: 'pass',
     },

bots/discord/src/commands/moderation/ban.ts

@@ -35,7 +35,7 @@ export default new ModerationCommand({
 
             if (moderator.roles.highest.comparePositionTo(member.roles.highest) <= 0)
                 throw new CommandError(
-                    CommandErrorType.InvalidUser,
+                    CommandErrorType.InvalidArgument,
                     'You cannot ban a user with a role equal to or higher than yours.',
                 )
         }

bots/discord/src/commands/moderation/mute.ts

@@ -37,14 +37,14 @@ export default new ModerationCommand({
 
         if (Number.isInteger(duration) && duration! < 1)
             throw new CommandError(
-                CommandErrorType.InvalidDuration,
+                CommandErrorType.InvalidArgument,
                 'The duration must be at least 1 millisecond long.',
             )
 
         const expires = Math.max(duration, Date.now() + duration)
         if (!member)
             throw new CommandError(
-                CommandErrorType.InvalidUser,
+                CommandErrorType.InvalidArgument,
                 'The provided member is not in the server or does not exist.',
             )
 
@@ -53,14 +53,14 @@ export default new ModerationCommand({
 
         if (moderator.roles.highest.comparePositionTo(member.roles.highest) <= 0)
             throw new CommandError(
-                CommandErrorType.InvalidUser,
+                CommandErrorType.InvalidArgument,
                 'You cannot mute a user with a role equal to or higher than yours.',
             )
 
         await applyRolePreset(member, 'mute', expires)
         await sendModerationReplyAndLogs(
             interaction,
-            createModerationActionEmbed('Muted', user, executor.user, reason, duration),
+            createModerationActionEmbed('Muted', user, executor.user, reason, Math.ceil(expires / 1000)),
         )
 
         if (duration)

bots/discord/src/commands/moderation/purge.ts

@@ -1,4 +1,4 @@
-import { EmbedBuilder, GuildChannel } from 'discord.js'
+import { EmbedBuilder } from 'discord.js'
 
 import { ModerationCommand } from '$/classes/Command'
 import CommandError, { CommandErrorType } from '$/classes/CommandError'
@@ -31,8 +31,8 @@ export default new ModerationCommand({
             throw new CommandError(CommandErrorType.MissingArgument, 'Either `amount` or `until` must be provided.')
 
         const channel = interaction.channel!
-        if (!(channel.isTextBased() && channel instanceof GuildChannel))
+        if (!channel.isTextBased())
-            throw new CommandError(CommandErrorType.InvalidChannel, 'The supplied channel is not a text channel.')
+            throw new CommandError(CommandErrorType.InvalidArgument, 'The supplied channel is not a text channel.')
 
         const embed = applyCommonEmbedStyles(
             new EmbedBuilder({

bots/discord/src/commands/moderation/role-preset.ts

@@ -45,7 +45,7 @@ export default new ModerationCommand({
 
         if (!member)
             throw new CommandError(
-                CommandErrorType.InvalidUser,
+                CommandErrorType.InvalidArgument,
                 'The provided member is not in the server or does not exist.',
             )
 
@@ -56,13 +56,13 @@ export default new ModerationCommand({
             const duration = durationInput ? parseDuration(durationInput) : Infinity
             if (Number.isInteger(duration) && duration! < 1)
                 throw new CommandError(
-                    CommandErrorType.InvalidDuration,
+                    CommandErrorType.InvalidArgument,
                     'The duration must be at least 1 millisecond long.',
                 )
 
             if (moderator.roles.highest.comparePositionTo(member.roles.highest) <= 0)
                 throw new CommandError(
-                    CommandErrorType.InvalidUser,
+                    CommandErrorType.InvalidArgument,
                     'You cannot apply a role preset to a user with a role equal to or higher than yours.',
                 )
 
@@ -83,6 +83,6 @@ export default new ModerationCommand({
                 removeRolePreset(member, preset)
             }, expires)
 
-        await sendPresetReplyAndLogs(apply ? 'apply' : 'remove', trigger, executor, user, preset, expires)
+        await sendPresetReplyAndLogs(apply ? 'apply' : 'remove', trigger, executor, user, preset, expires ? Math.ceil(expires / 1000) : undefined)
     },
 })

bots/discord/src/commands/moderation/slowmode.ts

@@ -27,14 +27,14 @@ export default new ModerationCommand({
 
         if (!channel?.isTextBased() || channel.isDMBased())
             throw new CommandError(
-                CommandErrorType.InvalidChannel,
+                CommandErrorType.InvalidArgument,
-                'The supplied channel is not a text channel or does not exist.',
+                'The supplied channel is not a text channel.',
             )
 
-        if (Number.isNaN(duration)) throw new CommandError(CommandErrorType.InvalidDuration, 'Invalid duration.')
+        if (Number.isNaN(duration)) throw new CommandError(CommandErrorType.InvalidArgument, 'Invalid duration.')
         if (duration < 0 || duration > 36e4)
             throw new CommandError(
-                CommandErrorType.InvalidDuration,
+                CommandErrorType.InvalidArgument,
                 'Duration out of range, must be between 0s and 6h.',
             )
 

bots/discord/src/commands/moderation/unmute.ts

@@ -20,7 +20,7 @@ export default new ModerationCommand({
         const member = await interaction.guild!.members.fetch(user.id)
         if (!member)
             throw new CommandError(
-                CommandErrorType.InvalidUser,
+                CommandErrorType.InvalidArgument,
                 'The provided member is not in the server or does not exist.',
             )
 

bots/discord/src/commands/support/train/chat.ts

@@ -0,0 +1,76 @@
+import Command from '$/classes/Command'
+import CommandError, { CommandErrorType } from '$/classes/CommandError'
+import { config } from '../../../context'
+import type { FetchMessageOptions, MessageResolvable } from 'discord.js'
+import type { ConfigMessageScanResponseLabelConfig } from 'config.schema'
+import { createSuccessEmbed } from '$/utils/discord/embeds'
+
+const msRcConfig = config.messageScan?.humanCorrections?.allow
+
+export default new Command({
+    name: 'train',
+    description: 'Train a specific message or text to a specific label',
+    type: Command.Type.ChatGuild,
+    requirements: {
+        users: msRcConfig?.users,
+        roles: msRcConfig?.members?.roles,
+        permissions: msRcConfig?.members?.permissions,
+        mode: 'any',
+        memberRequirementsForUsers: 'fail',
+        defaultCondition: 'fail',
+    },
+    options: {
+        message: {
+            description: 'The message to train (use `latest` to train the latest message)',
+            type: Command.OptionType.String,
+            required: true,
+        },
+        label: {
+            description: 'The label to train the message as',
+            type: Command.OptionType.String,
+            required: true,
+        },
+    },
+    allowMessageCommand: true,
+    async execute(context, trigger, { label, message: ref }) {
+        const { logger, config } = context
+        const { messageScan: msConfig } = config
+
+        // If there's no config, we can't do anything
+        if (!msConfig?.humanCorrections) throw new CommandError(CommandErrorType.Generic, 'Response correction is off.')
+        const labels = msConfig.responses?.flatMap(r =>
+            r.triggers.text!.filter((t): t is ConfigMessageScanResponseLabelConfig => 'label' in t).map(t => t.label),
+        )
+
+        const channel = await trigger.guild!.channels.fetch(trigger.channelId)
+        if (!channel?.isTextBased())
+            throw new CommandError(
+                CommandErrorType.InvalidArgument,
+                'This command can only be used in or on text channels',
+            )
+
+        if (!labels.includes(label))
+            throw new CommandError(
+                CommandErrorType.InvalidArgument,
+                `The provided label is invalid.\nValid labels are:${labels.map(l => `\n- \`${l}\``).join('')}`,
+            )
+
+        const refMsg = await channel.messages.fetch(
+            (ref.startsWith('latest') ? { limit: 1 } : ref) as MessageResolvable | FetchMessageOptions,
+        )
+        if (!refMsg) throw new CommandError(CommandErrorType.InvalidArgument, 'The provided message does not exist.')
+
+        logger.debug(`User ${context.executor.id} is training message ${refMsg?.id} as ${label}`)
+
+        await context.api.client.trainMessage(refMsg.content, label)
+        await trigger.reply({
+            embeds: [
+                createSuccessEmbed(
+                    'Message trained',
+                    `The provided message has been trained as \`${label}\`. Thank you for your contribution!`,
+                ),
+            ],
+            ephemeral: true,
+        })
+    },
+})

bots/discord/src/commands/support/train/context-menu.ts

@@ -0,0 +1,50 @@
+import Command from '$/classes/Command'
+import CommandError, { CommandErrorType } from '$/classes/CommandError'
+import { config } from '../../../context'
+import { type APIStringSelectComponent, ComponentType } from 'discord.js'
+import type { ConfigMessageScanResponseLabelConfig } from 'config.schema'
+
+const msRcConfig = config.messageScan?.humanCorrections?.allow
+
+export default new Command({
+    name: 'Train Message',
+    type: Command.Type.ContextMenuGuildMessage,
+    requirements: {
+        users: msRcConfig?.users,
+        roles: msRcConfig?.members?.roles,
+        permissions: msRcConfig?.members?.permissions,
+        mode: 'any',
+        memberRequirementsForUsers: 'fail',
+        defaultCondition: 'fail',
+    },
+    async execute(context, trigger) {
+        const { logger, config } = context
+        const { messageScan: msConfig } = config
+
+        // If there's no config, we can't do anything
+        if (!msConfig?.humanCorrections) throw new CommandError(CommandErrorType.Generic, 'Response correction is off.')
+
+        logger.debug(`User ${context.executor.id} is training message ${trigger.targetId}`)
+
+        const labels = msConfig.responses.flatMap(r =>
+            r.triggers.text!.filter((t): t is ConfigMessageScanResponseLabelConfig => 'label' in t).map(t => t.label),
+        )
+
+        await trigger.reply({
+            content: 'Select a label to train this message as:',
+            components: [
+                {
+                    components: [
+                        {
+                            custom_id: `tr_${trigger.targetMessage.channelId}_${trigger.targetId}`,
+                            options: labels.map(label => ({ label, value: label })),
+                            type: ComponentType.StringSelect,
+                        } satisfies APIStringSelectComponent,
+                    ],
+                    type: ComponentType.ActionRow,
+                },
+            ],
+            ephemeral: true,
+        })
+    },
+})

bots/discord/src/constants.ts

@@ -4,12 +4,6 @@ export const MessageScanLabeledResponseReactions = {
     delete: '❌',
 } as const
 
-export const MessageScanHumanizedMode = {
-    ocr: 'image recognition',
-    nlp: 'text analysis',
-    match: 'pattern matching',
-} as const
-
 export const DefaultEmbedColor = '#4E98F0'
 export const ReVancedLogoURL =
     'https://media.discordapp.net/attachments/1095487869923119144/1115436493050224660/revanced-logo.png'

bots/discord/src/context.ts

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, readdirSync } from 'fs'
 import { join } from 'path'
 import { Client as APIClient } from '@revanced/bot-api'
 import { createLogger } from '@revanced/bot-shared'
-import { Client as DiscordClient, Partials } from 'discord.js'
+import { Client as DiscordClient, type Message, Partials } from 'discord.js'
 import { drizzle } from 'drizzle-orm/bun-sqlite'
 
 // Export some things first, as commands require them
@@ -17,7 +17,7 @@ export const logger = createLogger({
 import * as commands from './commands'
 import * as schemas from './database/schemas'
 
-import type { default as Command, CommandOptionsOptions } from './classes/Command'
+import type { default as Command, CommandOptionsOptions, CommandType } from './classes/Command'
 
 export const api = {
     client: new APIClient({
@@ -56,7 +56,7 @@ if (DatabasePath && !existsSync(DatabasePath)) {
     }
 }
 
-const db = new Database(DatabasePath)
+const db = new Database(DatabasePath, { readwrite: true, create: true })
 if (dbSchemaFileName) db.run(readFileSync(join(DatabaseSchemaDir, dbSchemaFileName)).toString())
 
 export const database = drizzle(db, {
@@ -83,6 +83,28 @@ export const discord = {
     }),
     commands: Object.fromEntries(Object.values(commands).map(cmd => [cmd.name, cmd])) as Record<
         string,
-        Command<boolean, CommandOptionsOptions | undefined, boolean>
+        Command<CommandType, CommandOptionsOptions | undefined, boolean>
+    >,
+    stickyMessages: {} as Record<
+        string,
+        Record<
+            string,
+            {
+                /**
+                 * Chat is active, so force send timer is also active
+                 */
+                forceTimerActive: boolean
+                /**
+                 * There was a message sent, so the timer is active
+                 */
+                timerActive: boolean
+                timerMs: number
+                forceTimerMs?: number
+                send: (forced?: boolean) => Promise<void>
+                currentMessage?: Message<true>
+                timer?: NodeJS.Timeout
+                forceTimer?: NodeJS.Timeout
+            }
+        >
     >,
 } as const

bots/discord/src/events/discord/interactionCreate/chatCommand.ts

@@ -8,19 +8,24 @@ withContext(on, 'interactionCreate', async (context, interaction) => {
     const { logger, discord } = context
     const command = discord.commands[interaction.commandName]
 
-    logger.debug(`Command ${interaction.commandName} being invoked by ${interaction.user.tag}`)
+    logger.debug(`Command ${interaction.commandName} being invoked by ${interaction.user.tag} via chat`)
     if (!command)
-        return void logger.error(`Interaction command ${interaction.commandName} not implemented but registered!!!`)
+        return void logger.error(`Chat command ${interaction.commandName} not implemented but registered!!!`)
 
     try {
-        logger.debug(`Command ${interaction.commandName} being executed`)
+        logger.debug(`Command ${interaction.commandName} being executed via chat`)
         await command.onInteraction(context, interaction)
     } catch (err) {
         if (!(err instanceof CommandError))
             logger.error(`Error while executing command ${interaction.commandName}:`, err)
+
         await interaction[interaction.replied ? 'followUp' : 'reply']({
             embeds: [err instanceof CommandError ? err.toEmbed() : createStackTraceEmbed(err)],
             ephemeral: true,
         })
+
+        // 100 and up are user errors
+        if (err instanceof CommandError && err.type < 100)
+            logger.error(`Command ${interaction.commandName} internally failed with error:`, err)
     }
 })

bots/discord/src/events/discord/interactionCreate/contextMenuCommand.ts

@@ -0,0 +1,26 @@
+import CommandError from '$/classes/CommandError'
+import { createStackTraceEmbed } from '$utils/discord/embeds'
+import { on, withContext } from '$utils/discord/events'
+
+withContext(on, 'interactionCreate', async (context, interaction) => {
+    if (!interaction.isContextMenuCommand()) return
+
+    const { logger, discord } = context
+    const command = discord.commands[interaction.commandName]
+
+    logger.debug(`Command ${interaction.commandName} being invoked by ${interaction.user.tag} via context menu`)
+    if (!command)
+        return void logger.error(`Context menu command ${interaction.commandName} not implemented but registered!!!`)
+
+    try {
+        logger.debug(`Command ${interaction.commandName} being executed via context menu`)
+        await command.onContextMenuInteraction(context, interaction)
+    } catch (err) {
+        if (!(err instanceof CommandError))
+            logger.error(`Error while executing command ${interaction.commandName}:`, err)
+        await interaction[interaction.replied ? 'followUp' : 'reply']({
+            embeds: [err instanceof CommandError ? err.toEmbed() : createStackTraceEmbed(err)],
+            ephemeral: true,
+        })
+    }
+})

bots/discord/src/events/discord/interactionCreate/correctResponse.ts

@@ -18,10 +18,10 @@ withContext(on, 'interactionCreate', async (context, interaction) => {
     if (!interaction.isStringSelectMenu() && !interaction.isButton()) return
     if (!interaction.customId.startsWith('cr_')) return
 
-    const [, key, action] = interaction.customId.split('_') as ['cr', string, 'select' | 'cancel' | 'delete']
+    const [, msgId, action] = interaction.customId.split('_') as ['cr', string, 'select' | 'cancel' | 'delete']
-    if (!key || !action) return
+    if (!msgId || !action) return
 
-    const response = await db.query.responses.findFirst({ where: eq(responses.replyId, key) })
+    const response = await db.query.responses.findFirst({ where: eq(responses.replyId, msgId) })
     // If the message isn't saved in my DB (unrelated message)
     if (!response)
         return void (await interaction.reply({
@@ -32,11 +32,11 @@ withContext(on, 'interactionCreate', async (context, interaction) => {
     try {
         // We're gonna pretend reactionChannel is a text-based channel, but it can be many more
         // But `messages` should always exist as a property
-        const reactionGuild = await interaction.client.guilds.fetch(response.guildId)
+        const guild = await interaction.client.guilds.fetch(response.guildId)
-        const reactionChannel = (await reactionGuild.channels.fetch(response.channelId)) as TextBasedChannel | null
+        const channel = (await guild.channels.fetch(response.channelId)) as TextBasedChannel | null
-        const reactionMessage = await reactionChannel?.messages.fetch(key)
+        const msg = await channel?.messages.fetch(msgId)
 
-        if (!reactionMessage) {
+        if (!msg) {
             await interaction.deferUpdate()
             await interaction.message.edit({
                 content: null,
@@ -53,9 +53,9 @@ withContext(on, 'interactionCreate', async (context, interaction) => {
         }
 
         const editMessage = (content: string, description?: string) =>
-            editInteractionMessage(interaction, reactionMessage.url, content, description)
+            editInteractionMessage(interaction, msg.url, content, description)
         const handleCorrection = (label: string) =>
-            handleUserResponseCorrection(context, response, reactionMessage, label, interaction.user)
+            handleUserResponseCorrection(context, response, msg, label, interaction.user)
 
         if (response.correctedById)
             return await editMessage(

bots/discord/src/events/discord/interactionCreate/trainMessage.ts

@@ -0,0 +1,52 @@
+import { createErrorEmbed, createStackTraceEmbed, createSuccessEmbed } from '$utils/discord/embeds'
+import { on, withContext } from '$utils/discord/events'
+
+import type { TextBasedChannel } from 'discord.js'
+
+withContext(on, 'interactionCreate', async (context, interaction) => {
+    const {
+        logger,
+        config: { messageScan: msConfig },
+    } = context
+
+    if (!msConfig?.humanCorrections) return
+    if (!interaction.isStringSelectMenu()) return
+    if (!interaction.customId.startsWith('tr_')) return
+
+    const [, channelId, msgId] = interaction.customId.split('_') as ['tr', string, string]
+    if (!channelId || !msgId) return
+
+    try {
+        const channel = (await interaction.client.channels.fetch(channelId)) as TextBasedChannel | null
+        const msg = await channel?.messages.fetch(msgId)
+
+        if (!msg)
+            return void (await interaction.reply({
+                embeds: [
+                    createErrorEmbed(
+                        'Message not found',
+                        'Thank you for your contribution! Unfortunately, the message could not be found.',
+                    ),
+                ],
+                ephemeral: true,
+            }))
+
+        const selectedLabel = interaction.values[0]!
+        await context.api.client.trainMessage(msg.content, selectedLabel)
+        await interaction.reply({
+            embeds: [
+                createSuccessEmbed(
+                    'Message being trained',
+                    `Thank you for your contribution! The selected message is being trained as \`${selectedLabel}\`. 🎉`,
+                ),
+            ],
+            ephemeral: true,
+        })
+    } catch (e) {
+        logger.error('Failed to handle train message interaction:', e)
+        await interaction.reply({
+            embeds: [createStackTraceEmbed(e)],
+            ephemeral: true,
+        })
+    }
+})

bots/discord/src/events/discord/messageCreate/messageCommand.ts

@@ -18,7 +18,7 @@ withContext(on, 'messageCreate', async (context, msg) => {
     if (!commandName) return
 
     const command = discord.commands[commandName]
-    logger.debug(`Command ${commandName} being invoked by ${msg.author.id}`)
+    logger.debug(`Command ${commandName} being invoked by ${msg.author.id} via message`)
     if (!command) return void logger.debug(`Message command ${commandName} not implemented`)
 
     const argsRegex: RegExp = /[^\s"]+|"([^"]*)"/g
@@ -46,7 +46,7 @@ withContext(on, 'messageCreate', async (context, msg) => {
     }
 
     try {
-        logger.debug(`Command ${commandName} being executed`)
+        logger.debug(`Command ${commandName} being executed via message`)
         await command.onMessage(context, msg, args)
     } catch (err) {
         if (!(err instanceof CommandError)) logger.error(`Error while executing command ${commandName}:`, err)

bots/discord/src/events/discord/messageCreate/messageScan.ts

@@ -24,7 +24,7 @@ withContext(on, 'messageCreate', async (context, msg) => {
         try {
             logger.debug(`Classifying message ${msg.id}`)
 
-            const { response, label, replyToReplied } = await getResponseFromText(
+            const { response, label, respondToReply } = await getResponseFromText(
                 msg.content,
                 filteredResponses,
                 context,
@@ -33,14 +33,14 @@ withContext(on, 'messageCreate', async (context, msg) => {
             if (response) {
                 logger.debug('Response found')
 
-                const toReply = replyToReplied ? (msg.reference?.messageId ? await msg.fetchReference() : msg) : msg
+                const toReply = respondToReply ? (msg.reference?.messageId ? await msg.fetchReference() : msg) : msg
                 const reply = await toReply.reply({
                     ...response,
-                    embeds: response.embeds?.map(it => createMessageScanResponseEmbed(it, label ? 'nlp' : 'match')),
+                    embeds: response.embeds?.map(createMessageScanResponseEmbed),
                 })
 
-                if (label)
+                if (label) {
-                    db.insert(responses).values({
+                    await db.insert(responses).values({
                         replyId: reply.id,
                         channelId: reply.channel.id,
                         guildId: reply.guild!.id,
@@ -49,7 +49,6 @@ withContext(on, 'messageCreate', async (context, msg) => {
                         content: msg.content,
                     })
 
-                if (label) {
                     for (const reaction of Object.values(MessageScanLabeledResponseReactions)) {
                         await reply.react(reaction)
                     }
@@ -60,27 +59,50 @@ withContext(on, 'messageCreate', async (context, msg) => {
         }
     }
 
-    if (msg.attachments.size > 0) {
+    if (msg.attachments.size && config.attachments?.scanAttachments) {
         logger.debug(`Classifying message attachments for ${msg.id}`)
 
         for (const attachment of msg.attachments.values()) {
-            if (attachment.contentType && !config.allowedAttachmentMimeTypes.includes(attachment.contentType)) continue
+            const mimeType = attachment.contentType?.split(';')?.[0]
+            if (!mimeType) return void logger.warn(`No MIME type for attachment: ${attachment.url}`)
+
+            if (
+                config.attachments.allowedMimeTypes &&
+                !config.attachments.allowedMimeTypes.includes(mimeType)
+            ) {
+                logger.debug(`Disallowed MIME type for attachment: ${attachment.url}, ${mimeType}`)
+                continue
+            }
+
+            const isTextFile = mimeType.startsWith('text/')
+
+            if (isTextFile && attachment.size > (config.attachments.maxTextFileSize ?? 512 * 1000)) {
+                logger.debug(`Attachment ${attachment.url} is too large be to scanned, size is ${attachment.size}`)
+                continue
+            }
 
             try {
-                const { text: content } = await api.client.parseImage(attachment.url)
+                let response: Awaited<ReturnType<typeof getResponseFromText>>['response'] | undefined
-                const { response } = await getResponseFromText(content, filteredResponses, context, true)
+
+                if (isTextFile) {
+                    const content = await (await fetch(attachment.url)).text()
+                    response = await getResponseFromText(content, filteredResponses, context, { skipApiRequest: true }).then(it => it.response)
+                } else {
+                    const { text: content } = await api.client.parseImage(attachment.url)
+                    response = await getResponseFromText(content, filteredResponses, context, { onlyImageTriggers: true }).then(it => it.response)
+                }
 
                 if (response) {
                     logger.debug(`Response found for attachment: ${attachment.url}`)
                     await msg.reply({
                         ...response,
-                        embeds: response.embeds?.map(it => createMessageScanResponseEmbed(it, 'ocr')),
+                        embeds: response.embeds?.map(createMessageScanResponseEmbed),
                     })
 
                     break
                 }
-            } catch {
+            } catch (e) {
-                logger.error(`Failed to parse image: ${attachment.url}`)
+                logger.error(`Failed to parse attachment: ${attachment.url}`, e)
             }
         }
     }

bots/discord/src/events/discord/messageCreate/stickyMessageReset.ts

@@ -0,0 +1,38 @@
+import { on, withContext } from '$utils/discord/events'
+
+withContext(on, 'messageCreate', async ({ discord, logger }, msg) => {
+    if (!msg.inGuild()) return
+    if (msg.author.id === msg.client.user.id) return
+
+    const store = discord.stickyMessages[msg.guildId]?.[msg.channelId]
+    if (!store) return
+
+    const timerPreviouslyActive = store.timerActive
+    // If there isn't a timer, start it up
+    store.timerActive = true
+    if (!store.timer) store.timer = setTimeout(store.send, store.timerMs) as NodeJS.Timeout
+    else {
+        // If there is a timer, but it isn't active, restart it
+        if (!timerPreviouslyActive) store.timer.refresh()
+        // If there is a timer and it is active, but the force timer isn't active...
+        else if (!store.forceTimerActive && store.forceTimerMs) {
+            logger.debug(`Channel ${msg.channelId} in guild ${msg.guildId} is active, starting force send timer and clearing existing timer`)
+
+            // Clear the timer
+            clearTimeout(store.timer)
+            store.timerActive = false
+            store.forceTimerActive = true
+
+            // (Re)start the force timer
+            if (!store.forceTimer)
+                store.forceTimer = setTimeout(
+                    () =>
+                        store.send(true).then(() => {
+                            store.forceTimerActive = false
+                        }),
+                    store.forceTimerMs,
+                ) as NodeJS.Timeout
+            else store.forceTimer.refresh()
+        }
+    }
+})

bots/discord/src/events/discord/messageReactionAdd/correctResponse.ts

@@ -32,13 +32,11 @@ withContext(on, 'messageReactionAdd', async (context, rct, user) => {
 
     if (reactionMessage.author.id !== reaction.client.user!.id) return
     if (!PossibleReactions.includes(reaction.emoji.name!)) return
+    await rct.users.remove(user.id)
 
     if (!isAdmin(reactionMessage.member || reactionMessage.author)) {
         // User is in guild, and config has member requirements
-        if (
+        if (reactionMessage.inGuild() && msConfig.humanCorrections.allow) {
-            reactionMessage.inGuild() &&
-            (msConfig.humanCorrections.allow?.members || msConfig.humanCorrections.allow?.users)
-        ) {
             const {
                 allow: { users: allowedUsers, members: allowedMembers },
             } = msConfig.humanCorrections
@@ -54,20 +52,19 @@ withContext(on, 'messageReactionAdd', async (context, rct, user) => {
                     )
                 )
                     return
-            } else if (allowedUsers) {
+            } else if (!allowedUsers?.includes(user.id)) return
-                if (!allowedUsers.includes(user.id)) return
+        } else
-            } else {
+            return void logger.warn(
-                return void logger.warn(
+                'No member or user requirements set for human corrections, all requests will be ignored',
-                    'No member or user requirements set for human corrections, all requests will be ignored',
+            )
-                )
-            }
-        }
     }
 
     // Sanity check
     const response = await db.query.responses.findFirst({ where: eq(responses.replyId, rct.message.id) })
     if (!response || response.correctedById) return
 
+    logger.debug(`User ${user.id} is trying to correct the response ${rct.message.id}`)
+
     const handleCorrection = (label: string) =>
         handleUserResponseCorrection(context, response, reactionMessage, label, user)
 

bots/discord/src/events/discord/ready.ts

@@ -1,14 +1,82 @@
 import { database, logger } from '$/context'
 import { appliedPresets } from '$/database/schemas'
+import { applyCommonEmbedStyles } from '$/utils/discord/embeds'
+import { on, withContext } from '$/utils/discord/events'
 import { removeRolePreset } from '$/utils/discord/rolePresets'
-import type { Client } from 'discord.js'
 import { lt } from 'drizzle-orm'
-import { on, withContext } from 'src/utils/discord/events'
 
-export default withContext(on, 'ready', ({ config, logger }, client) => {
+import type { Client } from 'discord.js'
+
+export default withContext(on, 'ready', async ({ config, discord, logger }, client) => {
     logger.info(`Connected to Discord API, logged in as ${client.user.displayName} (@${client.user.tag})!`)
     logger.info(`Bot is in ${client.guilds.cache.size} guilds`)
 
+    if (config.stickyMessages)
+        for (const [guildId, channels] of Object.entries(config.stickyMessages)) {
+            const guild = await client.guilds.fetch(guildId)
+            // In case of configuration refresh, this will not be nullable
+            const oldStore = discord.stickyMessages[guildId]
+            discord.stickyMessages[guildId] = {}
+
+            for (const [channelId, { message, timeout, forceSendTimeout }] of Object.entries(channels)) {
+                const channel = await guild.channels.fetch(channelId)
+                if (!channel?.isTextBased())
+                    return void logger.warn(
+                        `Channel ${channelId} in guild ${guildId} is not a text channel, sticky messages will not be sent`,
+                    )
+
+                const send = async (forced = false) => {
+                    try {
+                        const msg = await channel.send({
+                            ...message,
+                            embeds: message.embeds?.map(it => applyCommonEmbedStyles(it, true, true, true)),
+                        })
+
+                        const store = discord.stickyMessages[guildId]![channelId]
+                        if (!store) return
+
+                        await store.currentMessage?.delete().catch()
+                        store.currentMessage = msg
+
+                        // Clear any remaining timers
+                        clearTimeout(store.timer)
+                        clearTimeout(store.forceTimer)
+                        store.forceTimerActive = store.timerActive = false
+
+                        if (!forced)
+                            logger.debug(
+                                `Timeout ended for sticky message in channel ${channelId} in guild ${guildId}, channel is inactive`,
+                            )
+                        else
+                            logger.debug(
+                                `Forced send timeout for sticky message in channel ${channelId} in guild ${guildId} ended, channel is too active`,
+                            )
+
+                        logger.debug(`Sent sticky message to channel ${channelId} in guild ${guildId}`)
+                    } catch (e) {
+                        logger.error(
+                            `Error while sending sticky message to channel ${channelId} in guild ${guildId}:`,
+                            e,
+                        )
+                    }
+                }
+                
+                // Set up the store
+                discord.stickyMessages[guildId]![channelId] = {
+                    forceTimerActive: false,
+                    timerActive: false,
+                    forceTimerMs: forceSendTimeout,
+                    timerMs: timeout,
+                    send,
+                    // If the store exists before the configuration refresh, take its current message
+                    currentMessage: oldStore?.[channelId]?.currentMessage
+                }
+
+                // Send a new sticky message immediately, as well as deleting the old/outdated message, if it exists
+                await send()
+            }
+        }
+
     if (config.rolePresets) {
         removeExpiredPresets(client)
         setTimeout(() => removeExpiredPresets(client), config.rolePresets.checkExpiredEvery)

bots/discord/src/utils/discord/embeds.ts

@@ -1,5 +1,5 @@
-import { DefaultEmbedColor, MessageScanHumanizedMode, ReVancedLogoURL } from '$/constants'
+import { DefaultEmbedColor, ReVancedLogoURL } from '$/constants'
-import { EmbedBuilder, type EmbedField, type User } from 'discord.js'
+import { type APIEmbed, EmbedBuilder, type EmbedField, type JSONEncodable, type User } from 'discord.js'
 import type { ConfigMessageScanResponseMessage } from '../../../config.schema'
 
 export const createErrorEmbed = (title: string | null, description?: string) =>
@@ -25,23 +25,7 @@ export const createSuccessEmbed = (title: string | null, description?: string) =
 
 export const createMessageScanResponseEmbed = (
     response: NonNullable<ConfigMessageScanResponseMessage['embeds']>[number],
-    mode: 'ocr' | 'nlp' | 'match',
+) => applyCommonEmbedStyles(response, true, true, true)
-) => {
-    // biome-ignore lint/style/noParameterAssign: While this is confusing, it is fine for this purpose
-    if ('toJSON' in response) response = response.toJSON()
-
-    const embed = new EmbedBuilder().setTitle(response.title ?? null)
-
-    if (response.description) embed.setDescription(response.description)
-    if (response.fields) embed.addFields(response.fields)
-
-    embed.setFooter({
-        text: `ReVanced • Via ${MessageScanHumanizedMode[mode]}`,
-        iconURL: ReVancedLogoURL,
-    })
-
-    return applyCommonEmbedStyles(embed, true, true, true)
-}
 
 export const createModerationActionEmbed = (
     action: string,
@@ -77,19 +61,23 @@ export const applyReferenceToModerationActionEmbed = (embed: EmbedBuilder, refer
 }
 
 export const applyCommonEmbedStyles = (
-    embed: EmbedBuilder,
+    embed: EmbedBuilder | JSONEncodable<APIEmbed> | APIEmbed,
     setThumbnail = false,
     setFooter = false,
     setColor = false,
 ) => {
+    // biome-ignore lint/style/noParameterAssign: While this is confusing, it is fine for this purpose
+    if ('toJSON' in embed) embed = embed.toJSON()
+    const builder = new EmbedBuilder(embed)
+
     if (setFooter)
-        embed.setFooter({
+        builder.setFooter({
             text: 'ReVanced',
             iconURL: ReVancedLogoURL,
         })
 
-    if (setColor) embed.setColor(DefaultEmbedColor)
+    if (setColor) builder.setColor(DefaultEmbedColor)
-    if (setThumbnail) embed.setThumbnail(ReVancedLogoURL)
+    if (setThumbnail) builder.setThumbnail(ReVancedLogoURL)
 
-    return embed
+    return builder
 }

bots/discord/src/utils/discord/messageScan.ts

@@ -9,7 +9,7 @@ export const getResponseFromText = async (
     responses: ConfigMessageScanResponse[],
     // Just to be safe that we will never use data from the context parameter
     { api, logger }: Omit<typeof import('src/context'), 'config'>,
-    ocrMode = false,
+    flags: { onlyImageTriggers?: boolean; skipApiRequest?: boolean } = {}
 ): Promise<
     Omit<ConfigMessageScanResponse, 'triggers'> & { label?: string; triggers?: ConfigMessageScanResponse['triggers'] }
 > => {
@@ -31,7 +31,7 @@ export const getResponseFromText = async (
             triggers: { text: textTriggers, image: imageTriggers },
         } = trigger
 
-        if (ocrMode) {
+        if (flags.onlyImageTriggers) {
             if (imageTriggers)
                 for (const regex of imageTriggers)
                     if (regex.test(content)) {
@@ -57,36 +57,37 @@ export const getResponseFromText = async (
     }
 
     // If none of the regexes match, we can search for labels immediately
-    if (!responseConfig.triggers && !ocrMode) {
+    if (!responseConfig.triggers && !flags.onlyImageTriggers && !flags.skipApiRequest) {
         logger.debug('No match from before regexes, doing NLP')
         const scan = await api.client.parseText(content)
         if (scan.labels.length) {
             const matchedLabel = scan.labels[0]!
             logger.debug(`Message matched label with confidence: ${matchedLabel.name}, ${matchedLabel.confidence}`)
 
-            let triggerConfig: ConfigMessageScanResponseLabelConfig | undefined
+            let trigger: ConfigMessageScanResponseLabelConfig | undefined
-            const labelConfig = responses.find(x => {
+            const response = responses.find(x => {
                 const config = x.triggers.text!.find(
                     (x): x is ConfigMessageScanResponseLabelConfig => 'label' in x && x.label === matchedLabel.name,
                 )
-                if (config) triggerConfig = config
+                if (config) trigger = config
                 return config
             })
 
-            if (!labelConfig) {
+            if (!response) {
-                logger.warn(`No label config found for label ${matchedLabel.name}`)
+                logger.warn(`No response config found for label ${matchedLabel.name}`)
+                // This returns the default value set in line 17, which means no response matched
                 return responseConfig
             }
 
-            if (matchedLabel.confidence >= triggerConfig!.threshold) {
+            if (matchedLabel.confidence >= trigger!.threshold) {
                 logger.debug('Label confidence is enough')
-                responseConfig = labelConfig
+                responseConfig = { ...responseConfig, ...response, label: trigger!.label }
             }
         }
     }
 
     // If we still don't have a response config, we can match all regexes after the initial label trigger
-    if (!responseConfig.triggers) {
+    if (!responseConfig.triggers && flags.onlyImageTriggers) {
         logger.debug('No match from NLP, doing after regexes')
         for (let i = 0; i < responses.length; i++) {
             const {
@@ -94,8 +95,8 @@ export const getResponseFromText = async (
             } = responses[i]!
             const firstLabelIndex = firstLabelIndexes[i] ?? -1
 
-            for (let i = firstLabelIndex + 1; i < textTriggers!.length; i++) {
+            for (let j = firstLabelIndex + 1; j < textTriggers!.length; j++) {
-                const trigger = textTriggers![i]!
+                const trigger = textTriggers![j]!
 
                 if (trigger instanceof RegExp) {
                     if (trigger.test(content)) {
@@ -121,17 +122,19 @@ export const messageMatchesFilter = (message: Message, filter: NonNullable<Confi
     // If matches whitelist but also matches blacklist, will return false
     // If matches only whitelist, will return true
     // If matches neither, will return true
-    return whitelist
+    return (
-        ? (whitelist.channels?.includes(message.channelId) ?? true) ||
+        (whitelist
-              (whitelist.roles?.some(role => memberRoles.has(role)) ?? true) ||
+            ? whitelist.channels?.includes(message.channelId) ||
-              (whitelist.users?.includes(message.author.id) ?? true)
+              whitelist.roles?.some(role => memberRoles.has(role)) ||
-        : true &&
+              whitelist.users?.includes(message.author.id)
-              !(
+            : true) &&
-                  blacklist &&
+        !(
-                  (blacklist.channels?.includes(message.channelId) ||
+            blacklist &&
-                      blacklist.roles?.some(role => memberRoles.has(role)) ||
+            (blacklist.channels?.includes(message.channelId) ||
-                      blacklist.users?.includes(message.author.id))
+                blacklist.roles?.some(role => memberRoles.has(role)) ||
-              )
+                blacklist.users?.includes(message.author.id))
+        )
+    )
 }
 
 export const handleUserResponseCorrection = async (
@@ -158,7 +161,7 @@ export const handleUserResponseCorrection = async (
 
         await reply.edit({
             ...correctLabelResponse.response,
-            embeds: correctLabelResponse.response.embeds?.map(it => createMessageScanResponseEmbed(it, 'nlp')),
+            embeds: correctLabelResponse.response.embeds?.map(createMessageScanResponseEmbed),
         })
     }
 

bots/discord/src/utils/discord/moderation.ts

@@ -1,6 +1,6 @@
 import { config, logger } from '$/context'
 import decancer from 'decancer'
-import type { ChatInputCommandInteraction, EmbedBuilder, Guild, GuildMember, Message, User } from 'discord.js'
+import type { CommandInteraction, EmbedBuilder, Guild, GuildMember, Message, User } from 'discord.js'
 import { applyReferenceToModerationActionEmbed, createModerationActionEmbed } from './embeds'
 
 const PresetLogAction = {
@@ -10,7 +10,7 @@ const PresetLogAction = {
 
 export const sendPresetReplyAndLogs = (
     action: keyof typeof PresetLogAction,
-    interaction: ChatInputCommandInteraction | Message,
+    interaction: CommandInteraction | Message,
     executor: GuildMember,
     user: User,
     preset: string,
@@ -24,7 +24,7 @@ export const sendPresetReplyAndLogs = (
     )
 
 export const sendModerationReplyAndLogs = async (
-    interaction: ChatInputCommandInteraction | Message,
+    interaction: CommandInteraction | Message,
     embed: EmbedBuilder,
 ) => {
     const reply = await interaction.reply({ embeds: [embed] }).then(it => it.fetch())
@@ -38,7 +38,7 @@ export const getLogChannel = async (guild: Guild) => {
 
     try {
         const channel = await guild.channels.fetch(logConfig.thread ?? logConfig.channel)
-        if (!channel || !channel.isTextBased())
+        if (!channel?.isTextBased())
             return void logger.warn('The moderation log channel does not exist, skipping logging')
 
         return channel

bots/discord/src/utils/discord/permissions.ts

@@ -1,5 +1,5 @@
 import { GuildMember, type User } from 'discord.js'
-import config from '../../../config'
+import { config } from '../../context'
 
 export const isAdmin = (userOrMember: User | GuildMember) => {
     return (

bots/discord/src/utils/discord/rolePresets.ts

@@ -6,9 +6,9 @@ import { and, eq } from 'drizzle-orm'
 // TODO: Fix this type
 type PresetKey = string
 
-export const applyRolePreset = async (member: GuildMember, presetName: PresetKey, untilMs: number) => {
+export const applyRolePreset = async (member: GuildMember, presetName: PresetKey, expires: number) => {
     const afterInsert = await applyRolesUsingPreset(presetName, member, true)
-    const until = untilMs === Infinity ? null : Math.ceil(untilMs / 1000)
+    const until = expires === Infinity ? null : Math.ceil(expires / 1000)
 
     await database
         .insert(appliedPresets)

bots/discord/src/utils/duration.ts

@@ -1,13 +1,16 @@
 export const parseDuration = (duration: string) => {
     if (!duration.length) return Number.NaN
-    const matches = duration.match(/(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s?)?/)!
+    const matches = duration.match(/(?:(\d+y)?(\d+M)?(\d+w)?(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s?)/)!
 
-    const [, days, hours, minutes, seconds] = matches.map(Number)
+    const [, years, months, weeks, days, hours, minutes, seconds] = matches.map(Number)
     return (
-        (days || 0) * 24 * 60 * 60 * 1000 +
+        (years || 0) * 290304e5 +
-        (hours || 0) * 60 * 60 * 1000 +
+        (months || 0) * 24192e5 +
-        (minutes || 0) * 60 * 1000 +
+        (weeks || 0) * 6048e5 +
-        (seconds || 0) * 1000
+        (days || 0) * 864e5 +
+        (hours || 0) * 36e5 +
+        (minutes || 0) * 6e4 +
+        (seconds || 0) * 1e3
     )
 }
 

packages/api/src/classes/ClientWebSocket.ts

@@ -17,7 +17,7 @@ import { type RawData, WebSocket } from 'ws'
  * This is the only relevant class for the time being. But in the future, there may be more classes to handle different protocols of the API.
  */
 export class ClientWebSocketManager {
-    readonly url: string
+    url: string
     timeout: number
 
     connecting = false
@@ -33,6 +33,21 @@ export class ClientWebSocketManager {
         this.timeout = options.timeout ?? 10000
     }
 
+    /**
+     * Sets the URL to connect to
+     * 
+     * **Requires a reconnect to take effect**
+     */
+    async setOptions({ url, timeout }: Partial<ClientWebSocketManagerOptions>, autoReconnect = true) {
+        if (url) this.url = url
+        this.timeout = timeout ?? this.timeout
+
+        if (autoReconnect) {
+            this.disconnect(true)
+            await this.connect()
+        }
+    }
+
     /**
      * Connects to the WebSocket API
      * @returns A promise that resolves when the client is ready
@@ -77,9 +92,13 @@ export class ClientWebSocketManager {
             } catch (e) {
                 rj(e)
             }
-        }).finally(() => {
-            this.connecting = false
         })
+            .then(() => {
+                this.#socket.on('close', (code, reason) => this._handleDisconnect(code, reason.toString()))
+            })
+            .finally(() => {
+                this.connecting = false
+            })
     }
 
     /**

packages/shared/src/schemas/Packet.ts

@@ -1,9 +1,9 @@
 import {
-    url,
     type AnySchema,
     type NullSchema,
     type ObjectSchema,
     type Output,
+    type BooleanSchema,
     array,
     enum_,
     null_,
@@ -11,6 +11,8 @@ import {
     parse,
     special,
     string,
+    boolean,
+    url,
     // merge
 } from 'valibot'
 import DisconnectReason from '../constants/DisconnectReason'
@@ -26,8 +28,7 @@ export const PacketSchema = special<Packet>(input => {
         'op' in input &&
         typeof input.op === 'number' &&
         input.op in Operation &&
-        'd' in input &&
+        'd' in input
-        typeof input.d === 'object'
     ) {
         if (input.op in ServerOperation && !('s' in input && typeof input.s === 'number')) return false
 
@@ -62,7 +63,7 @@ export const PacketDataSchemas = {
     [ServerOperation.Disconnect]: object({
         reason: enum_(DisconnectReason),
     }),
-    [ServerOperation.TrainedMessage]: null_(),
+    [ServerOperation.TrainedMessage]: boolean(),
     [ServerOperation.TrainMessageFailed]: null_(),
 
     [ClientOperation.ParseText]: object({
@@ -78,7 +79,7 @@ export const PacketDataSchemas = {
 } as const satisfies Record<
     Operation,
     // biome-ignore lint/suspicious/noExplicitAny: This is a schema, it's not possible to type it
-    ObjectSchema<any> | AnySchema | NullSchema
+    ObjectSchema<any> | AnySchema | NullSchema | BooleanSchema
 >
 
 export type Packet<TOp extends Operation = Operation> = TOp extends ServerOperation