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

# @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](de8bef6520))
* **bots/discord:** make `/eval` work ([eaa25f2](eaa25f2eb5))
* **bots/discord:** some configuration values not applying after running `/reload` ([a976dd2](a976dd2acc))

bots/discord/CHANGELOG.md

@@ -1,3 +1,19 @@
+# @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)
 
 

bots/discord/package.json

@@ -2,7 +2,7 @@
   "name": "@revanced/discord-bot",
   "type": "module",
   "private": true,
-  "version": "1.0.0-dev.19",
+  "version": "1.0.0-dev.21",
   "description": "🤖 Discord bot assisting ReVanced",
   "main": "src/index.ts",
   "scripts": {

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

@@ -1,5 +1,4 @@
 import { inspect } from 'util'
-import { runInThisContext } from 'vm'
 import { ApplicationCommandOptionType } from 'discord.js'
 
 import { AdminCommand } from '$/classes/Command'
@@ -26,7 +25,14 @@ export default new AdminCommand({
             embeds: [
                 createSuccessEmbed('Evaluate', `\`\`\`js\n${code}\`\`\``).addFields({
                     name: 'Result',
-                    value: `\`\`\`js\n${inspect(runInThisContext(code), { 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(eval(code), {
+                        depth: 1,
+                        showHidden,
+                        getters: true,
+                        numericSeparator: true,
+                        showProxy: true,
+                    })}\`\`\``,
                 }),
             ],
         })

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

@@ -7,11 +7,29 @@ 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
 
-        await trigger.reply({
-            content: 'Reloaded configuration',
-            ephemeral: true,
-        })
+        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()
+        await discord.client.login()
+
+        // @ts-expect-error: TypeScript dum
+        await trigger[('deferReply' in trigger ? 'editReply' : 'reply')]({ content: 'Reloaded configuration' })
     },
 })

bots/discord/src/context.ts

@@ -90,13 +90,20 @@ export const discord = {
         Record<
             string,
             {
-                forceSendTimerActive?: boolean
-                timeoutMs: number
-                forceSendMs?: number
+                /**
+                 * 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>
-                interval?: NodeJS.Timeout
-                forceSendInterval?: NodeJS.Timeout
+                timer?: NodeJS.Timeout
+                forceTimer?: NodeJS.Timeout
             }
         >
     >,

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

@@ -7,24 +7,31 @@ withContext(on, 'messageCreate', async ({ discord, logger }, msg) => {
     const store = discord.stickyMessages[msg.guildId]?.[msg.channelId]
     if (!store) return
 
-    if (!store.interval) store.interval = setTimeout(store.send, store.timeoutMs) as NodeJS.Timeout
+    // 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 {
-        store.interval.refresh()
+        // If there is a timer, but it isn't active, restart it
+        if (!store.timerActive) 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`)
 
-        if (!store.forceSendTimerActive && store.forceSendMs) {
-            logger.debug(`Channel ${msg.channelId} in guild ${msg.guildId} is active, starting force send timer`)
+            // Clear the timer
+            clearTimeout(store.timer)
+            store.timerActive = false
+            store.forceTimerActive = true
 
-            store.forceSendTimerActive = true
-
-            if (!store.forceSendInterval)
-                store.forceSendInterval = setTimeout(
+            // (Re)start the force timer
+            if (!store.forceTimer)
+                store.forceTimer = setTimeout(
                     () =>
                         store.send(true).then(() => {
-                            store.forceSendTimerActive = false
+                            store.forceTimerActive = false
                         }),
-                    store.forceSendMs,
+                    store.forceTimerMs,
                 ) as NodeJS.Timeout
-            else store.forceSendInterval.refresh()
+            else store.forceTimer.refresh()
         }
     }
 })

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

@@ -14,11 +14,16 @@ export default withContext(on, 'ready', async ({ config, discord, logger }, clie
     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
+                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 {
@@ -33,17 +38,19 @@ export default withContext(on, 'ready', async ({ config, discord, logger }, clie
                         await store.currentMessage?.delete().catch()
                         store.currentMessage = msg
 
-                        if (!forced) {
-                            clearTimeout(store.forceSendInterval)
+                        // 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 {
-                            clearTimeout(store.interval)
+                        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) {
@@ -53,13 +60,20 @@ export default withContext(on, 'ready', async ({ config, discord, logger }, clie
                         )
                     }
                 }
-
+                
+                // Set up the store
                 discord.stickyMessages[guildId]![channelId] = {
-                    forceSendMs: forceSendTimeout,
-                    timeoutMs: timeout,
+                    forceTimerActive: false,
+                    timerActive: false,
+                    forceTimerMs: forceSendTimeout,
+                    timerMs: timeout,
                     send,
-                    forceSendTimerActive: false,
+                    // 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()
             }
         }
 

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