feat: custom bot status rotation

biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.4.5/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.4.7/schema.json",
   "files": {
     "includes": [
       "src/**/*.js",

config.json

@@ -150,6 +150,28 @@
       "flushIntervalMs": 5000
     }
   },
+  "botStatus": {
+    "enabled": true,
+    "status": "online",
+    "rotation": {
+      "enabled": true,
+      "intervalMinutes": 5,
+      "messages": [
+        {
+          "type": "Watching",
+          "text": "{guildCount} servers"
+        },
+        {
+          "type": "Listening",
+          "text": "to {memberCount} members"
+        },
+        {
+          "type": "Playing",
+          "text": "with /help"
+        }
+      ]
+    }
+  },
   "permissions": {
     "enabled": true,
     "adminRoleIds": [],

src/api/routes/guilds.js

@@ -727,40 +727,51 @@
  *       "500":
  *         $ref: "#/components/responses/ServerError"
  */
 router.patch('/:id/config', requireGuildAdmin, validateGuild, async (req, res) => {
   if (!req.body) {
     return res.status(400).json({ error: 'Request body is required' });
   }
 
   const result = validateConfigPatchBody(req.body, SAFE_CONFIG_KEYS);
   if (result.error) {
     const response = { error: result.error };
     if (result.details) response.details = result.details;
     return res.status(result.status).json(response);
   }
 
   const { path, value, topLevelKey } = result;
+  // botStatus is global (not per-guild) — only bot owners may write to it.
+  const isGlobalBotStatusWrite = topLevelKey === 'botStatus';
+  if (isGlobalBotStatusWrite && req.authMethod === 'oauth' && !isOAuthBotOwner(req.user)) {
+    return res.status(403).json({ error: 'Only bot owners can update global bot status' });
+  }
+  const writeScope = isGlobalBotStatusWrite ? 'global' : req.params.id;
 
   try {
-    await setConfigValue(path, value, req.params.id);
-    const effectiveConfig = getConfig(req.params.id);
+    await setConfigValue(path, value, writeScope === 'global' ? undefined : req.params.id);
+    const effectiveConfig = writeScope === 'global' ? getConfig() : getConfig(req.params.id);
     const effectiveSection = effectiveConfig[topLevelKey] || {};
     const sensitivePattern = /key|secret|token|password/i;
     const logValue = sensitivePattern.test(path) ? '[REDACTED]' : value;
-    info('Config updated via API', { path, value: logValue, guild: req.params.id });
+    info('Config updated via API', {
+      path,
+      value: logValue,
+      guild: req.params.id,
+      scope: writeScope,
+    });
     fireAndForgetWebhook('DASHBOARD_WEBHOOK_URL', {
       event: 'config.updated',
       guildId: req.params.id,
       section: topLevelKey,
       updatedKeys: [path],
       timestamp: Date.now(),
     });
     res.json(effectiveSection);
   } catch (err) {
     error('Failed to update config via API', { path, error: err.message });
     res.status(500).json({ error: 'Failed to update config' });
   }
 });
 
 /**
  * @openapi

src/api/utils/configValidation.js

@@ -177,6 +177,40 @@
       retentionDays: { type: 'number', min: 1, max: 365 },
     },
   },
+  botStatus: {
+    type: 'object',
+    properties: {
+      enabled: { type: 'boolean' },
+      status: { type: 'string', enum: ['online', 'idle', 'dnd', 'invisible'] },
+      activityType: {
+        type: 'string',
+        enum: ['Playing', 'Watching', 'Listening', 'Competing', 'Streaming', 'Custom'],
+      },
+      activities: { type: 'array', items: { type: 'string' } },
+      rotateIntervalMs: { type: 'number' },
+      rotation: {
+        type: 'object',
+        properties: {
+          enabled: { type: 'boolean' },
+          intervalMinutes: { type: 'number' },
+          messages: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                type: {
+                  type: 'string',
+                  enum: ['Playing', 'Watching', 'Listening', 'Competing', 'Streaming', 'Custom'],
+                },
+                text: { type: 'string', minLength: 1, pattern: '\\S' },
+              },
+              required: ['text'],
+            },
+          },
+        },
+      },
+    },
+  },
   reminders: {
     type: 'object',
     properties: {
@@ -251,12 +285,18 @@
       if (typeof value !== 'string') {
         errors.push(`${path}: expected string, got ${typeof value}`);
       } else {
+        if (typeof schema.minLength === 'number' && value.length < schema.minLength) {
+          errors.push(`${path}: must be at least ${schema.minLength} characters`);
+        }
         if (schema.enum && !schema.enum.includes(value)) {
           errors.push(`${path}: must be one of [${schema.enum.join(', ')}], got "${value}"`);
         }
         if (schema.maxLength != null && value.length > schema.maxLength) {
           errors.push(`${path}: exceeds max length of ${schema.maxLength}`);
         }
+        if (schema.pattern && !new RegExp(schema.pattern).test(value)) {
+          errors.push(`${path}: does not match required pattern`);
+        }
       }
       break;
     case 'number':
@@ -276,24 +316,7 @@
         errors.push(`${path}: expected array, got ${typeof value}`);
       } else if (schema.items) {
         for (let i = 0; i < value.length; i++) {
-          const item = value[i];
-          if (schema.items.type === 'string') {
-            if (typeof item !== 'string') {
-              errors.push(`${path}[${i}]: expected string, got ${typeof item}`);
-            }
-          } else if (schema.items.type === 'object') {
-            if (typeof item !== 'object' || item === null || Array.isArray(item)) {
-              errors.push(
-                `${path}[${i}]: expected object, got ${Array.isArray(item) ? 'array' : item === null ? 'null' : typeof item}`,
-              );
-            } else if (schema.items.required) {
-              for (const key of schema.items.required) {
-                if (!(key in item)) {
-                  errors.push(`${path}[${i}]: missing required key "${key}"`);
-                }
-              }
-            }
-          }
+          errors.push(...validateValue(value[i], schema.items, `${path}[${i}]`));
         }
       }
       break;
@@ -302,14 +325,24 @@
         errors.push(
           `${path}: expected object, got ${Array.isArray(value) ? 'array' : typeof value}`,
         );
-      } else if (schema.properties) {
-        for (const [key, val] of Object.entries(value)) {
-          if (Object.hasOwn(schema.properties, key)) {
-            errors.push(...validateValue(val, schema.properties[key], `${path}.${key}`));
-          } else if (!schema.openProperties) {
-            errors.push(`${path}.${key}: unknown config key`);
+      } else {
+        if (schema.required) {
+          for (const key of schema.required) {
+            if (!Object.hasOwn(value, key)) {
+              errors.push(`${path}: missing required key "${key}"`);
+            }
+          }
+        }
+
+        if (schema.properties) {
+          for (const [key, val] of Object.entries(value)) {
+            if (Object.hasOwn(schema.properties, key)) {
+              errors.push(...validateValue(val, schema.properties[key], `${path}.${key}`));
+            } else if (!schema.openProperties) {
+              errors.push(`${path}.${key}: unknown config key`);
+            }
+            // openProperties: true — freeform map, unknown keys are allowed
           }
-          // openProperties: true — freeform map, unknown keys are allowed
         }
       }
       break;

src/config-listeners.js

@@ -113,6 +113,10 @@ export function registerConfigListeners({ dbPool, config }) {
     'botStatus.activityType',
     'botStatus.activities',
     'botStatus.rotateIntervalMs',
+    'botStatus.rotation',
+    'botStatus.rotation.enabled',
+    'botStatus.rotation.intervalMinutes',
+    'botStatus.rotation.messages',
   ]) {
     onConfigChange(key, (_newValue, _oldValue, _path, guildId) => {
       // Bot presence is global — ignore per-guild overrides here

src/index.js

@@ -42,6 +42,7 @@ import {
   startConversationCleanup,
   stopConversationCleanup,
 } from './modules/ai.js';
+import { startBotStatus, stopBotStatus } from './modules/botStatus.js';
 import { loadConfig } from './modules/config.js';
 
 import { registerEventHandlers } from './modules/events.js';
@@ -193,6 +194,7 @@ async function gracefulShutdown(signal) {
   stopWarningExpiryScheduler();
   stopScheduler();
   stopGithubFeed();
+  stopBotStatus();
 
   // 1.5. Stop API server (drain in-flight HTTP requests before closing DB)
   try {
@@ -379,6 +381,9 @@ async function startup() {
   await loadCommands();
   await client.login(token);
 
+  // Start configurable bot presence rotation after login so client.user is available
+  startBotStatus(client);
+
   // Set Sentry context now that we know the bot identity (no-op if disabled)
   import('./sentry.js')
     .then(({ Sentry, sentryEnabled }) => {