+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| src | +
+
+ |
+ 26.2% | +60/229 | +34.28% | +36/105 | +31.42% | +11/35 | +26.24% | +58/221 | +
| src/commands | +
+
+ |
+ 28.99% | +49/169 | +15.95% | +15/94 | +46.42% | +13/28 | +29.26% | +48/164 | +
| src/modules | +
+
+ |
+ 25.18% | +139/552 | +23.17% | +89/384 | +27.27% | +21/77 | +25.14% | +128/509 | +
| src/utils | +
+
+ |
+ 28.12% | +45/160 | +44.89% | +66/147 | +17.85% | +5/28 | +28.38% | +44/155 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 | + + + + + + + + + + + + + + + + +1x + + + +1x + + + +1x + + + + + + + +1x + + + +1x + + + + + + +1x + + + + + + + + +1x + + + +1x + + + + + + + +1x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +1x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | /**
+ * Config Command
+ * View, set, and reset bot configuration via slash commands
+ */
+
+import { EmbedBuilder, SlashCommandBuilder } from 'discord.js';
+import { getConfig, resetConfig, setConfigValue } from '../modules/config.js';
+
+/**
+ * Escape backticks in user-provided strings to prevent breaking Discord inline code formatting.
+ * @param {string} str - Raw string to sanitize
+ * @returns {string} Sanitized string safe for embedding inside backtick-delimited code spans
+ */
+function escapeInlineCode(str) {
+ return String(str).replace(/`/g, '\\`');
+}
+
+export const data = new SlashCommandBuilder()
+ .setName('config')
+ .setDescription('View or manage bot configuration (Admin only)')
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('view')
+ .setDescription('View current configuration')
+ .addStringOption((option) =>
+ option
+ .setName('section')
+ .setDescription('Specific config section to view')
+ .setRequired(false)
+ .setAutocomplete(true),
+ ),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('set')
+ .setDescription('Set a configuration value')
+ .addStringOption((option) =>
+ option
+ .setName('path')
+ .setDescription('Dot-notation path (e.g., ai.model, welcome.enabled)')
+ .setRequired(true)
+ .setAutocomplete(true),
+ )
+ .addStringOption((option) =>
+ option
+ .setName('value')
+ .setDescription(
+ 'Value (auto-coerces true/false/null/numbers; use "\\"text\\"" for literal strings)',
+ )
+ .setRequired(true),
+ ),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('reset')
+ .setDescription('Reset configuration to defaults from config.json')
+ .addStringOption((option) =>
+ option
+ .setName('section')
+ .setDescription('Section to reset (omit to reset all)')
+ .setRequired(false)
+ .setAutocomplete(true),
+ ),
+ );
+
+export const adminOnly = true;
+
+/**
+ * Recursively collect leaf-only dot-notation paths for a config object.
+ * Only emits paths that point to non-object values (leaves).
+ * @param {*} source - Config value to traverse
+ * @param {string} [prefix] - Current path prefix
+ * @param {string[]} [paths] - Accumulator array
+ * @returns {string[]} Dot-notation config paths (leaf-only)
+ */
+function collectConfigPaths(source, prefix = '', paths = []) {
+ if (Array.isArray(source)) {
+ // Emit path for empty arrays so they're discoverable in autocomplete
+ if (source.length === 0 && prefix) {
+ paths.push(prefix);
+ return paths;
+ }
+ source.forEach((value, index) => {
+ const path = prefix ? `${prefix}.${index}` : String(index);
+ if (value && typeof value === 'object') {
+ collectConfigPaths(value, path, paths);
+ } else {
+ paths.push(path);
+ }
+ });
+ return paths;
+ }
+
+ if (!source || typeof source !== 'object') {
+ return paths;
+ }
+
+ // Emit path for empty objects so they're discoverable in autocomplete
+ if (Object.keys(source).length === 0 && prefix) {
+ paths.push(prefix);
+ return paths;
+ }
+
+ for (const [key, value] of Object.entries(source)) {
+ const path = prefix ? `${prefix}.${key}` : key;
+ if (value && typeof value === 'object') {
+ collectConfigPaths(value, path, paths);
+ } else {
+ paths.push(path);
+ }
+ }
+
+ return paths;
+}
+
+/**
+ * Handle autocomplete for config paths and section names
+ * @param {Object} interaction - Discord interaction
+ */
+export async function autocomplete(interaction) {
+ const focusedOption = interaction.options.getFocused(true);
+ const focusedValue = focusedOption.value.toLowerCase().trim();
+ const config = getConfig();
+
+ let choices;
+ if (focusedOption.name === 'section') {
+ // Autocomplete section names from live config
+ choices = Object.keys(config)
+ .filter((s) => s.toLowerCase().includes(focusedValue))
+ .slice(0, 25)
+ .map((s) => ({ name: s, value: s }));
+ } else {
+ // Autocomplete dot-notation paths (leaf-only)
+ const paths = collectConfigPaths(config);
+ choices = paths
+ .filter((p) => p.toLowerCase().includes(focusedValue))
+ .sort((a, b) => {
+ const aLower = a.toLowerCase();
+ const bLower = b.toLowerCase();
+ const aStartsWithFocus = aLower.startsWith(focusedValue);
+ const bStartsWithFocus = bLower.startsWith(focusedValue);
+ if (aStartsWithFocus !== bStartsWithFocus) {
+ return aStartsWithFocus ? -1 : 1;
+ }
+ return aLower.localeCompare(bLower);
+ })
+ .slice(0, 25)
+ .map((p) => ({ name: p, value: p }));
+ }
+
+ await interaction.respond(choices);
+}
+
+/**
+ * Execute the config command
+ * @param {Object} interaction - Discord interaction
+ */
+export async function execute(interaction) {
+ const subcommand = interaction.options.getSubcommand();
+
+ switch (subcommand) {
+ case 'view':
+ await handleView(interaction);
+ break;
+ case 'set':
+ await handleSet(interaction);
+ break;
+ case 'reset':
+ await handleReset(interaction);
+ break;
+ default:
+ await interaction.reply({
+ content: `❌ Unknown subcommand: \`${subcommand}\``,
+ ephemeral: true,
+ });
+ break;
+ }
+}
+
+/** @type {number} Discord embed total character limit */
+const EMBED_CHAR_LIMIT = 6000;
+
+/**
+ * Handle /config view
+ */
+async function handleView(interaction) {
+ try {
+ const config = getConfig();
+ const section = interaction.options.getString('section');
+
+ const embed = new EmbedBuilder()
+ .setColor(0x5865f2)
+ .setTitle('⚙️ Bot Configuration')
+ .setFooter({
+ text: `${process.env.DATABASE_URL ? 'Stored in PostgreSQL' : 'Stored in memory (config.json)'} • Use /config set to modify`,
+ })
+ .setTimestamp();
+
+ if (section) {
+ const sectionData = config[section];
+ if (!sectionData) {
+ const safeSection = escapeInlineCode(section);
+ return await interaction.reply({
+ content: `❌ Section \`${safeSection}\` not found in config`,
+ ephemeral: true,
+ });
+ }
+
+ embed.setDescription(`**${section.toUpperCase()} Configuration**`);
+ const sectionJson = JSON.stringify(sectionData, null, 2);
+ embed.addFields({
+ name: 'Settings',
+ value:
+ '```json\n' +
+ (sectionJson.length > 1000 ? `${sectionJson.slice(0, 997)}...` : sectionJson) +
+ '\n```',
+ });
+ } else {
+ embed.setDescription('Current bot configuration');
+
+ // Track cumulative embed size to stay under Discord's 6000-char limit
+ let totalLength = (embed.data.title?.length || 0) + (embed.data.description?.length || 0);
+ let truncated = false;
+
+ for (const [key, value] of Object.entries(config)) {
+ const jsonStr = JSON.stringify(value, null, 2);
+ const fieldValue = `\`\`\`json\n${jsonStr.length > 1000 ? `${jsonStr.slice(0, 997)}...` : jsonStr}\n\`\`\``;
+ const fieldName = key.toUpperCase();
+ const fieldLength = fieldName.length + fieldValue.length;
+
+ if (totalLength + fieldLength > EMBED_CHAR_LIMIT - 200) {
+ // Reserve space for a truncation notice
+ embed.addFields({
+ name: '⚠️ Truncated',
+ value: 'Use `/config view section:<name>` to see remaining sections.',
+ inline: false,
+ });
+ truncated = true;
+ break;
+ }
+
+ totalLength += fieldLength;
+ embed.addFields({
+ name: fieldName,
+ value: fieldValue,
+ inline: false,
+ });
+ }
+
+ if (truncated) {
+ embed.setFooter({
+ text: 'Some sections omitted • Use /config view section:<name> for details',
+ });
+ }
+ }
+
+ await interaction.reply({ embeds: [embed], ephemeral: true });
+ } catch (err) {
+ await interaction.reply({
+ content: `❌ Failed to load config: ${err.message}`,
+ ephemeral: true,
+ });
+ }
+}
+
+/**
+ * Handle /config set
+ */
+async function handleSet(interaction) {
+ const path = interaction.options.getString('path');
+ const value = interaction.options.getString('value');
+
+ // Validate section exists in live config
+ const section = path.split('.')[0];
+ const validSections = Object.keys(getConfig());
+ if (!validSections.includes(section)) {
+ const safeSection = escapeInlineCode(section);
+ return await interaction.reply({
+ content: `❌ Invalid section \`${safeSection}\`. Valid sections: ${validSections.join(', ')}`,
+ ephemeral: true,
+ });
+ }
+
+ try {
+ await interaction.deferReply({ ephemeral: true });
+
+ const updatedSection = await setConfigValue(path, value);
+
+ // Traverse to the actual leaf value for display
+ const leafValue = path
+ .split('.')
+ .slice(1)
+ .reduce((obj, k) => obj?.[k], updatedSection);
+
+ const displayValue = JSON.stringify(leafValue, null, 2) ?? value;
+ const truncatedValue =
+ displayValue.length > 1000 ? `${displayValue.slice(0, 997)}...` : displayValue;
+
+ const embed = new EmbedBuilder()
+ .setColor(0x57f287)
+ .setTitle('✅ Config Updated')
+ .addFields(
+ { name: 'Path', value: `\`${path}\``, inline: true },
+ { name: 'New Value', value: `\`${truncatedValue}\``, inline: true },
+ )
+ .setFooter({ text: 'Changes take effect immediately' })
+ .setTimestamp();
+
+ await interaction.editReply({ embeds: [embed] });
+ } catch (err) {
+ const content = `❌ Failed to set config: ${err.message}`;
+ if (interaction.deferred) {
+ await interaction.editReply({ content });
+ } else {
+ await interaction.reply({ content, ephemeral: true });
+ }
+ }
+}
+
+/**
+ * Handle /config reset
+ */
+async function handleReset(interaction) {
+ const section = interaction.options.getString('section');
+
+ try {
+ await interaction.deferReply({ ephemeral: true });
+
+ await resetConfig(section || undefined);
+
+ const embed = new EmbedBuilder()
+ .setColor(0xfee75c)
+ .setTitle('🔄 Config Reset')
+ .setDescription(
+ section
+ ? `Section **${section}** has been reset to defaults from config.json.`
+ : 'All configuration has been reset to defaults from config.json.',
+ )
+ .setFooter({ text: 'Changes take effect immediately' })
+ .setTimestamp();
+
+ await interaction.editReply({ embeds: [embed] });
+ } catch (err) {
+ const content = `❌ Failed to reset config: ${err.message}`;
+ if (interaction.deferred) {
+ await interaction.editReply({ content });
+ } else {
+ await interaction.reply({ content, ephemeral: true });
+ }
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| config.js | +
+
+ |
+ 8.26% | +10/121 | +0% | +0/70 | +33.33% | +7/21 | +8.26% | +10/121 | +
| ping.js | +
+
+ |
+ 100% | +6/6 | +100% | +0/0 | +100% | +1/1 | +100% | +6/6 | +
| status.js | +
+
+ |
+ 78.57% | +33/42 | +62.5% | +15/24 | +83.33% | +5/6 | +86.48% | +32/37 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 | + +2x + + + + +9x + + + + +9x +9x +9x + +9x + + | import { SlashCommandBuilder } from 'discord.js';
+
+export const data = new SlashCommandBuilder()
+ .setName('ping')
+ .setDescription('Check bot latency and responsiveness');
+
+export async function execute(interaction) {
+ const response = await interaction.reply({
+ content: 'Pinging...',
+ withResponse: true,
+ });
+
+ const sent = response.resource.message;
+ const latency = sent.createdTimestamp - interaction.createdTimestamp;
+ const apiLatency = Math.round(interaction.client.ws.ping);
+
+ await interaction.editReply(`🏓 Pong!\n📡 Latency: ${latency}ms\n💓 API: ${apiLatency}ms`);
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 | + + + + + + + + + + +2x + + + +2x + + + + + + + + + +16x + +16x +16x +16x +16x +16x +16x + +16x +16x +16x + + + + + + + + +16x + +16x + + + + + + + + + + + + + +21x +21x +21x + +21x + +9x +1x + + + +1x + + + +8x + +8x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +8x + + +8x + +8x + + + + + + + + + + + + + + + + + + + + +8x + + +4x + +4x + + + + +4x +2x + +2x + + + + | /**
+ * Status Command - Display bot health metrics
+ *
+ * Shows uptime, memory usage, API status, and last AI request
+ * Admin mode (detailed: true) shows additional diagnostics
+ */
+
+import { EmbedBuilder, PermissionFlagsBits, SlashCommandBuilder } from 'discord.js';
+import { error as logError } from '../logger.js';
+import { HealthMonitor } from '../utils/health.js';
+
+export const data = new SlashCommandBuilder()
+ .setName('status')
+ .setDescription('Display bot health metrics and status')
+ .addBooleanOption((option) =>
+ option
+ .setName('detailed')
+ .setDescription('Show detailed diagnostics (admin only)')
+ .setRequired(false),
+ );
+
+/**
+ * Format timestamp as relative time
+ */
+function formatRelativeTime(timestamp) {
+ Iif (!timestamp) return 'Never';
+
+ const now = Date.now();
+ const diff = now - timestamp;
+ const seconds = Math.floor(diff / 1000);
+ const minutes = Math.floor(seconds / 60);
+ const hours = Math.floor(minutes / 60);
+ const days = Math.floor(hours / 24);
+
+ Iif (diff < 1000) return 'Just now';
+ Iif (seconds < 60) return `${seconds}s ago`;
+ Eif (minutes < 60) return `${minutes}m ago`;
+ if (hours < 24) return `${hours}h ago`;
+ return `${days}d ago`;
+}
+
+/**
+ * Get status emoji based on API status
+ */
+function getStatusEmoji(status) {
+ switch (status) {
+ case 'ok':
+ return '🟢';
+ case 'error':
+ return '🔴';
+ case 'unknown':
+ return '🟡';
+ default:
+ return '⚪';
+ }
+}
+
+/**
+ * Execute the status command
+ */
+export async function execute(interaction) {
+ try {
+ const detailed = interaction.options.getBoolean('detailed') || false;
+ const healthMonitor = HealthMonitor.getInstance();
+
+ if (detailed) {
+ // Check if user has admin permissions
+ if (!interaction.memberPermissions?.has(PermissionFlagsBits.Administrator)) {
+ await interaction.reply({
+ content: '❌ Detailed diagnostics are only available to administrators.',
+ ephemeral: true,
+ });
+ return;
+ }
+
+ // Detailed mode - admin diagnostics
+ const status = healthMonitor.getDetailedStatus();
+
+ const embed = new EmbedBuilder()
+ .setColor(0x5865f2)
+ .setTitle('🔍 Bot Status - Detailed Diagnostics')
+ .addFields(
+ { name: '⏱️ Uptime', value: status.uptimeFormatted, inline: true },
+ { name: '🧠 Memory', value: status.memory.formatted, inline: true },
+ {
+ name: '🌐 API',
+ value: `${getStatusEmoji(status.api.status)} ${status.api.status}`,
+ inline: true,
+ },
+ {
+ name: '🤖 Last AI Request',
+ value: formatRelativeTime(status.lastAIRequest),
+ inline: true,
+ },
+ { name: '📊 Process ID', value: `${status.process.pid}`, inline: true },
+ { name: '🖥️ Platform', value: status.process.platform, inline: true },
+ { name: '📦 Node Version', value: status.process.nodeVersion, inline: true },
+ {
+ name: '⚙️ Process Uptime',
+ value: `${Math.floor(status.process.uptime)}s`,
+ inline: true,
+ },
+ { name: '🔢 Heap Used', value: `${status.memory.heapUsed}MB`, inline: true },
+ { name: '💾 RSS', value: `${status.memory.rss}MB`, inline: true },
+ { name: '📡 External', value: `${status.memory.external}MB`, inline: true },
+ { name: '🔢 Array Buffers', value: `${status.memory.arrayBuffers}MB`, inline: true },
+ )
+ .setTimestamp()
+ .setFooter({ text: 'Detailed diagnostics mode' });
+
+ await interaction.reply({ embeds: [embed], ephemeral: true });
+ } else {
+ // Basic mode - user-friendly status
+ const status = healthMonitor.getStatus();
+
+ const embed = new EmbedBuilder()
+ .setColor(0x57f287)
+ .setTitle('📊 Bot Status')
+ .setDescription('Current health and performance metrics')
+ .addFields(
+ { name: '⏱️ Uptime', value: status.uptimeFormatted, inline: true },
+ { name: '🧠 Memory', value: status.memory.formatted, inline: true },
+ {
+ name: '🌐 API Status',
+ value: `${getStatusEmoji(status.api.status)} ${status.api.status.toUpperCase()}`,
+ inline: true,
+ },
+ {
+ name: '🤖 Last AI Request',
+ value: formatRelativeTime(status.lastAIRequest),
+ inline: false,
+ },
+ )
+ .setTimestamp()
+ .setFooter({ text: 'Use /status detailed:true for more info' });
+
+ await interaction.reply({ embeds: [embed] });
+ }
+ } catch (err) {
+ logError('Status command error', { error: err.message });
+
+ const reply = {
+ content: "Sorry, I couldn't retrieve the status. Try again in a moment!",
+ ephemeral: true,
+ };
+
+ if (interaction.replied || interaction.deferred) {
+ await interaction.followUp(reply).catch(() => {});
+ } else {
+ await interaction.reply(reply).catch(() => {});
+ }
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 | + + + + + + + +1x + + +1x + + +1x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | /**
+ * Database Module
+ * PostgreSQL connection pool and schema initialization
+ */
+
+import pg from 'pg';
+import { info, error as logError } from './logger.js';
+
+const { Pool } = pg;
+
+/** @type {pg.Pool | null} */
+let pool = null;
+
+/** @type {boolean} Re-entrancy guard for initDb */
+let initializing = false;
+
+/**
+ * Determine SSL configuration based on DATABASE_SSL env var and connection string.
+ *
+ * DATABASE_SSL values:
+ * "false" / "off" → SSL disabled
+ * "no-verify" → SSL enabled but server cert not verified
+ * "true" / "on" / unset → SSL enabled with full verification
+ *
+ * Railway internal connections always disable SSL regardless of env var.
+ *
+ * @param {string} connectionString - Database connection URL
+ * @returns {false|{rejectUnauthorized: boolean}} SSL config for pg.Pool
+ */
+function getSslConfig(connectionString) {
+ // Railway internal connections never need SSL
+ if (connectionString.includes('railway.internal')) {
+ return false;
+ }
+
+ const sslEnv = (process.env.DATABASE_SSL || '').toLowerCase().trim();
+
+ if (sslEnv === 'false' || sslEnv === 'off') {
+ return false;
+ }
+
+ if (sslEnv === 'no-verify') {
+ return { rejectUnauthorized: false };
+ }
+
+ // Default: SSL with full verification
+ return { rejectUnauthorized: true };
+}
+
+/**
+ * Initialize the database connection pool and create schema
+ * @returns {Promise<pg.Pool>} The connection pool
+ */
+export async function initDb() {
+ if (pool) return pool;
+ if (initializing) {
+ throw new Error('initDb is already in progress');
+ }
+
+ initializing = true;
+ try {
+ const connectionString = process.env.DATABASE_URL;
+ if (!connectionString) {
+ throw new Error('DATABASE_URL environment variable is not set');
+ }
+
+ pool = new Pool({
+ connectionString,
+ max: 5,
+ idleTimeoutMillis: 30000,
+ connectionTimeoutMillis: 10000,
+ ssl: getSslConfig(connectionString),
+ });
+
+ // Prevent unhandled pool errors from crashing the process
+ pool.on('error', (err) => {
+ logError('Unexpected database pool error', { error: err.message });
+ });
+
+ try {
+ // Test connection
+ const client = await pool.connect();
+ try {
+ await client.query('SELECT NOW()');
+ info('Database connected');
+ } finally {
+ client.release();
+ }
+
+ // Create schema
+ await pool.query(`
+ CREATE TABLE IF NOT EXISTS config (
+ key TEXT PRIMARY KEY,
+ value JSONB NOT NULL,
+ updated_at TIMESTAMPTZ DEFAULT NOW()
+ )
+ `);
+
+ info('Database schema initialized');
+ } catch (err) {
+ // Clean up the pool so getPool() doesn't return an unusable instance
+ await pool.end().catch(() => {});
+ pool = null;
+ throw err;
+ }
+
+ return pool;
+ } finally {
+ initializing = false;
+ }
+}
+
+/**
+ * Get the database pool
+ * @returns {pg.Pool} The connection pool
+ * @throws {Error} If pool is not initialized
+ */
+export function getPool() {
+ if (!pool) {
+ throw new Error('Database not initialized. Call initDb() first.');
+ }
+ return pool;
+}
+
+/**
+ * Gracefully close the database pool
+ */
+export async function closeDb() {
+ if (pool) {
+ try {
+ await pool.end();
+ info('Database pool closed');
+ } catch (err) {
+ logError('Error closing database pool', { error: err.message });
+ } finally {
+ pool = null;
+ }
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| db.js | +
+
+ |
+ 6.66% | +3/45 | +0% | +0/20 | +0% | +0/6 | +6.81% | +3/44 | +
| index.js | +
+
+ |
+ 0% | +0/122 | +0% | +0/38 | +0% | +0/18 | +0% | +0/117 | +
| logger.js | +
+
+ |
+ 91.93% | +57/62 | +76.59% | +36/47 | +100% | +11/11 | +91.66% | +55/60 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | /**
+ * Bill Bot - Volvox Discord Bot
+ * Main entry point - orchestrates modules
+ *
+ * Features:
+ * - AI chat powered by Claude
+ * - Welcome messages for new members
+ * - Spam/scam detection and moderation
+ * - Health monitoring and status command
+ * - Graceful shutdown handling
+ * - Structured logging
+ */
+
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client, Collection, GatewayIntentBits } from 'discord.js';
+import { config as dotenvConfig } from 'dotenv';
+import { closeDb, initDb } from './db.js';
+import { error, info, warn } from './logger.js';
+import { getConversationHistory, setConversationHistory } from './modules/ai.js';
+import { loadConfig } from './modules/config.js';
+import { registerEventHandlers } from './modules/events.js';
+import { HealthMonitor } from './utils/health.js';
+import { getPermissionError, hasPermission } from './utils/permissions.js';
+import { registerCommands } from './utils/registerCommands.js';
+
+// ES module dirname equivalent
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// State persistence path
+const dataDir = join(__dirname, '..', 'data');
+const statePath = join(dataDir, 'state.json');
+
+// Load environment variables
+dotenvConfig();
+
+// Config is loaded asynchronously after DB init (see startup below).
+// After loadConfig() resolves, `config` points to the same object as
+// configCache inside modules/config.js, so in-place mutations from
+// setConfigValue() propagate here automatically without re-assignment.
+let config = {};
+
+// Initialize Discord client with required intents
+const client = new Client({
+ intents: [
+ GatewayIntentBits.Guilds,
+ GatewayIntentBits.GuildMessages,
+ GatewayIntentBits.MessageContent,
+ GatewayIntentBits.GuildMembers,
+ GatewayIntentBits.GuildVoiceStates,
+ ],
+});
+
+// Initialize command collection
+client.commands = new Collection();
+
+// Initialize health monitor
+const healthMonitor = HealthMonitor.getInstance();
+
+// Track pending AI requests for graceful shutdown
+const pendingRequests = new Set();
+
+/**
+ * Register a pending request for tracking
+ * @returns {Symbol} Request ID to use for cleanup
+ */
+export function registerPendingRequest() {
+ const requestId = Symbol('request');
+ pendingRequests.add(requestId);
+ return requestId;
+}
+
+/**
+ * Remove a pending request from tracking
+ * @param {Symbol} requestId - Request ID to remove
+ */
+export function removePendingRequest(requestId) {
+ pendingRequests.delete(requestId);
+}
+
+/**
+ * Save conversation history to disk
+ */
+function saveState() {
+ try {
+ // Ensure data directory exists
+ if (!existsSync(dataDir)) {
+ mkdirSync(dataDir, { recursive: true });
+ }
+
+ const conversationHistory = getConversationHistory();
+ const stateData = {
+ conversationHistory: Array.from(conversationHistory.entries()),
+ timestamp: new Date().toISOString(),
+ };
+ writeFileSync(statePath, JSON.stringify(stateData, null, 2), 'utf-8');
+ info('State saved successfully');
+ } catch (err) {
+ error('Failed to save state', { error: err.message });
+ }
+}
+
+/**
+ * Load conversation history from disk
+ */
+function loadState() {
+ try {
+ if (!existsSync(statePath)) {
+ return;
+ }
+ const stateData = JSON.parse(readFileSync(statePath, 'utf-8'));
+ if (stateData.conversationHistory) {
+ setConversationHistory(new Map(stateData.conversationHistory));
+ info('State loaded successfully');
+ }
+ } catch (err) {
+ error('Failed to load state', { error: err.message });
+ }
+}
+
+/**
+ * Load all commands from the commands directory
+ */
+async function loadCommands() {
+ const commandsPath = join(__dirname, 'commands');
+ const commandFiles = readdirSync(commandsPath).filter((file) => file.endsWith('.js'));
+
+ for (const file of commandFiles) {
+ const filePath = join(commandsPath, file);
+ try {
+ const command = await import(filePath);
+ if (command.data && command.execute) {
+ client.commands.set(command.data.name, command);
+ info('Loaded command', { command: command.data.name });
+ } else {
+ warn('Command missing data or execute export', { file });
+ }
+ } catch (err) {
+ error('Failed to load command', { file, error: err.message });
+ }
+ }
+}
+
+// Event handlers are registered after config loads (see startup below)
+
+// Extend ready handler to register slash commands
+client.once('clientReady', async () => {
+ // Register slash commands with Discord
+ try {
+ const commands = Array.from(client.commands.values());
+ const guildId = process.env.GUILD_ID || null;
+
+ await registerCommands(commands, client.user.id, process.env.DISCORD_TOKEN, guildId);
+ } catch (err) {
+ error('Command registration failed', { error: err.message });
+ }
+});
+
+// Handle slash commands and autocomplete
+client.on('interactionCreate', async (interaction) => {
+ // Handle autocomplete
+ if (interaction.isAutocomplete()) {
+ const command = client.commands.get(interaction.commandName);
+ if (command?.autocomplete) {
+ try {
+ await command.autocomplete(interaction);
+ } catch (err) {
+ error('Autocomplete error', { command: interaction.commandName, error: err.message });
+ }
+ }
+ return;
+ }
+
+ if (!interaction.isChatInputCommand()) return;
+
+ const { commandName, member } = interaction;
+
+ try {
+ info('Slash command received', { command: commandName, user: interaction.user.tag });
+
+ // Permission check
+ if (!hasPermission(member, commandName, config)) {
+ await interaction.reply({
+ content: getPermissionError(commandName),
+ ephemeral: true,
+ });
+ warn('Permission denied', { user: interaction.user.tag, command: commandName });
+ return;
+ }
+
+ // Execute command from collection
+ const command = client.commands.get(commandName);
+ if (!command) {
+ await interaction.reply({
+ content: '❌ Command not found.',
+ ephemeral: true,
+ });
+ return;
+ }
+
+ await command.execute(interaction);
+ info('Command executed', { command: commandName, user: interaction.user.tag });
+ } catch (err) {
+ error('Command error', { command: commandName, error: err.message, stack: err.stack });
+
+ const errorMessage = {
+ content: '❌ An error occurred while executing this command.',
+ ephemeral: true,
+ };
+
+ if (interaction.replied || interaction.deferred) {
+ await interaction.followUp(errorMessage).catch(() => {});
+ } else {
+ await interaction.reply(errorMessage).catch(() => {});
+ }
+ }
+});
+
+/**
+ * Graceful shutdown handler
+ * @param {string} signal - Signal that triggered shutdown
+ */
+async function gracefulShutdown(signal) {
+ info('Shutdown initiated', { signal });
+
+ // 1. Wait for pending requests with timeout
+ const SHUTDOWN_TIMEOUT = 10000; // 10 seconds
+ if (pendingRequests.size > 0) {
+ info('Waiting for pending requests', { count: pendingRequests.size });
+ const startTime = Date.now();
+
+ while (pendingRequests.size > 0 && Date.now() - startTime < SHUTDOWN_TIMEOUT) {
+ await new Promise((resolve) => setTimeout(resolve, 100));
+ }
+
+ if (pendingRequests.size > 0) {
+ warn('Shutdown timeout, requests still pending', { count: pendingRequests.size });
+ } else {
+ info('All requests completed');
+ }
+ }
+
+ // 2. Save state after pending requests complete
+ info('Saving conversation state');
+ saveState();
+
+ // 3. Close database pool
+ info('Closing database connection');
+ try {
+ await closeDb();
+ } catch (err) {
+ error('Failed to close database pool', { error: err.message });
+ }
+
+ // 4. Destroy Discord client
+ info('Disconnecting from Discord');
+ client.destroy();
+
+ // 5. Log clean exit
+ info('Shutdown complete');
+ process.exit(0);
+}
+
+// Handle shutdown signals
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+
+// Error handling
+client.on('error', (err) => {
+ error('Discord client error', {
+ error: err.message,
+ stack: err.stack,
+ code: err.code,
+ });
+});
+
+process.on('unhandledRejection', (err) => {
+ error('Unhandled promise rejection', {
+ error: err?.message || String(err),
+ stack: err?.stack,
+ type: typeof err,
+ });
+});
+
+// Start bot
+const token = process.env.DISCORD_TOKEN;
+if (!token) {
+ error('DISCORD_TOKEN not set');
+ process.exit(1);
+}
+
+/**
+ * Main startup sequence
+ * 1. Initialize database
+ * 2. Load config from DB (seeds from config.json if empty)
+ * 3. Load previous conversation state
+ * 4. Register event handlers with live config
+ * 5. Load commands
+ * 6. Login to Discord
+ */
+async function startup() {
+ // Initialize database
+ if (process.env.DATABASE_URL) {
+ await initDb();
+ info('Database initialized');
+ } else {
+ warn('DATABASE_URL not set — using config.json only (no persistence)');
+ }
+
+ // Load config (from DB if available, else config.json)
+ config = await loadConfig();
+ info('Configuration loaded', { sections: Object.keys(config) });
+
+ // Load previous conversation state
+ loadState();
+
+ // Register event handlers with live config reference
+ registerEventHandlers(client, config, healthMonitor);
+
+ // Load commands and login
+ await loadCommands();
+ await client.login(token);
+}
+
+startup().catch((err) => {
+ error('Startup failed', { error: err.message, stack: err.stack });
+ process.exit(1);
+});
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 | + + + + + + + + + + + + + + + +5x +5x +5x + + +5x +5x + +5x +5x +5x +5x +5x + + + + + + + +5x +5x +5x + + + + + + + + + + + +5x + + + + + + + + + + + + + +5431x + + + +5431x + + + +5431x +4x + + +5429x +5429x + +75986x + +10856x +2x +10854x +5422x + +5432x + + + +6x + + + + + +5x + +148x + + +148x +514x + +217x +1487x + + +217x +8x +209x + +5x + + + + +147x + + + + + +5x + + + + + + + + + +5x +64x +64x + + + + + +5x + + +64x +64x + +64x + + + + + + +5x + + + + + + + + + + + + +5x +5x + + + + + + + + + + + + + + +5x + + + + + + + + + + + + + + + +5x + + + + + + + + + +1x + + + + + + +45x + + + + + + +1x + + + + + + +19x + + + + + + + + + + + | /**
+ * Structured Logger Module
+ *
+ * Provides centralized logging with:
+ * - Multiple log levels (debug, info, warn, error)
+ * - Timestamp formatting
+ * - Structured output
+ * - Console transport (file transport added in phase 3)
+ */
+
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import winston from 'winston';
+import DailyRotateFile from 'winston-daily-rotate-file';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const configPath = join(__dirname, '..', 'config.json');
+const logsDir = join(__dirname, '..', 'logs');
+
+// Load config to get log level and file output setting
+let logLevel = 'info';
+let fileOutputEnabled = false;
+
+try {
+ Eif (existsSync(configPath)) {
+ const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+ logLevel = process.env.LOG_LEVEL || config.logging?.level || 'info';
+ fileOutputEnabled = config.logging?.fileOutput || false;
+ }
+} catch (_err) {
+ // Fallback to default if config can't be loaded
+ logLevel = process.env.LOG_LEVEL || 'info';
+}
+
+// Create logs directory if file output is enabled
+Eif (fileOutputEnabled) {
+ try {
+ Iif (!existsSync(logsDir)) {
+ mkdirSync(logsDir, { recursive: true });
+ }
+ } catch (_err) {
+ // Log directory creation failed, but continue without file logging
+ fileOutputEnabled = false;
+ }
+}
+
+/**
+ * Sensitive field names that should be redacted from logs
+ */
+const SENSITIVE_FIELDS = [
+ 'DISCORD_TOKEN',
+ 'OPENCLAW_API_KEY',
+ 'OPENCLAW_TOKEN',
+ 'token',
+ 'password',
+ 'apiKey',
+ 'authorization',
+];
+
+/**
+ * Recursively filter sensitive data from objects
+ */
+function filterSensitiveData(obj) {
+ Iif (obj === null || obj === undefined) {
+ return obj;
+ }
+
+ Iif (typeof obj !== 'object') {
+ return obj;
+ }
+
+ if (Array.isArray(obj)) {
+ return obj.map((item) => filterSensitiveData(item));
+ }
+
+ const filtered = {};
+ for (const [key, value] of Object.entries(obj)) {
+ // Check if key matches any sensitive field (case-insensitive)
+ const isSensitive = SENSITIVE_FIELDS.some((field) => key.toLowerCase() === field.toLowerCase());
+
+ if (isSensitive) {
+ filtered[key] = '[REDACTED]';
+ } else if (typeof value === 'object' && value !== null) {
+ filtered[key] = filterSensitiveData(value);
+ } else {
+ filtered[key] = value;
+ }
+ }
+
+ return filtered;
+}
+
+/**
+ * Winston format that redacts sensitive data
+ */
+const redactSensitiveData = winston.format((info) => {
+ // Reserved winston properties that should not be filtered
+ const reserved = ['level', 'message', 'timestamp', 'stack'];
+
+ // Filter each property in the info object
+ for (const key in info) {
+ if (Object.hasOwn(info, key) && !reserved.includes(key)) {
+ // Check if this key is sensitive (case-insensitive)
+ const isSensitive = SENSITIVE_FIELDS.some(
+ (field) => key.toLowerCase() === field.toLowerCase(),
+ );
+
+ if (isSensitive) {
+ info[key] = '[REDACTED]';
+ } else if (typeof info[key] === 'object' && info[key] !== null) {
+ // Recursively filter nested objects
+ info[key] = filterSensitiveData(info[key]);
+ }
+ }
+ }
+
+ return info;
+})();
+
+/**
+ * Emoji mapping for log levels
+ */
+const EMOJI_MAP = {
+ error: '❌',
+ warn: '⚠️',
+ info: '✅',
+ debug: '🔍',
+};
+
+/**
+ * Format that stores the original level before colorization
+ */
+const preserveOriginalLevel = winston.format((info) => {
+ info.originalLevel = info.level;
+ return info;
+})();
+
+/**
+ * Custom format for console output with emoji prefixes
+ */
+const consoleFormat = winston.format.printf(
+ ({ level, message, timestamp, originalLevel, ...meta }) => {
+ // Use originalLevel for emoji lookup since 'level' may contain ANSI color codes
+ const prefix = EMOJI_MAP[originalLevel] || '📝';
+ const metaStr = Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : '';
+
+ return `${prefix} [${timestamp}] ${level.toUpperCase()}: ${message}${metaStr}`;
+ },
+);
+
+/**
+ * Create winston logger instance
+ */
+const transports = [
+ new winston.transports.Console({
+ format: winston.format.combine(
+ redactSensitiveData,
+ preserveOriginalLevel,
+ winston.format.colorize(),
+ winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+ consoleFormat,
+ ),
+ }),
+];
+
+// Add file transport if enabled in config
+Eif (fileOutputEnabled) {
+ transports.push(
+ new DailyRotateFile({
+ filename: join(logsDir, 'combined-%DATE%.log'),
+ datePattern: 'YYYY-MM-DD',
+ maxSize: '20m',
+ maxFiles: '14d',
+ format: winston.format.combine(
+ redactSensitiveData,
+ winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+ winston.format.json(),
+ ),
+ }),
+ );
+
+ // Separate transport for error-level logs only
+ transports.push(
+ new DailyRotateFile({
+ level: 'error',
+ filename: join(logsDir, 'error-%DATE%.log'),
+ datePattern: 'YYYY-MM-DD',
+ maxSize: '20m',
+ maxFiles: '14d',
+ format: winston.format.combine(
+ redactSensitiveData,
+ winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+ winston.format.json(),
+ ),
+ }),
+ );
+}
+
+const logger = winston.createLogger({
+ level: logLevel,
+ format: winston.format.combine(winston.format.errors({ stack: true }), winston.format.splat()),
+ transports,
+});
+
+/**
+ * Log at debug level
+ */
+export function debug(message, meta = {}) {
+ logger.debug(message, meta);
+}
+
+/**
+ * Log at info level
+ */
+export function info(message, meta = {}) {
+ logger.info(message, meta);
+}
+
+/**
+ * Log at warn level
+ */
+export function warn(message, meta = {}) {
+ logger.warn(message, meta);
+}
+
+/**
+ * Log at error level
+ */
+export function error(message, meta = {}) {
+ logger.error(message, meta);
+}
+
+// Default export for convenience
+export default {
+ debug,
+ info,
+ warn,
+ error,
+ logger, // Export winston logger instance for advanced usage
+};
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 | + + + + + + + +1x +1x + + + + + + +2x + + + + + + + +26x + + + + + + +1x + + +1x + + + + + + + +77x +21x + +77x + + + + + + + + + +54x +54x + + +54x +5x + + + + + + + + + + + + + + + + + + + +14x + + +14x + + + + + + +14x + + + + + + +14x + +14x +14x + + + + + + + + + + + + +13x +2x +1x + +2x + + +11x +11x + + +14x + + +14x +1x +1x + + + +11x +11x + +11x + +3x +3x +1x + +3x + + + | /**
+ * AI Module
+ * Handles AI chat functionality powered by Claude via OpenClaw
+ */
+
+import { error as logError, info } from '../logger.js';
+
+// Conversation history per channel (simple in-memory store)
+let conversationHistory = new Map();
+const MAX_HISTORY = 20;
+
+/**
+ * Get the full conversation history map (for state persistence)
+ * @returns {Map} Conversation history map
+ */
+export function getConversationHistory() {
+ return conversationHistory;
+}
+
+/**
+ * Set the conversation history map (for state restoration)
+ * @param {Map} history - Conversation history map to restore
+ */
+export function setConversationHistory(history) {
+ conversationHistory = history;
+}
+
+// OpenClaw API endpoint/token (exported for shared use by other modules)
+// Preferred env vars: OPENCLAW_API_URL + OPENCLAW_API_KEY
+// Backward-compatible aliases: OPENCLAW_URL + OPENCLAW_TOKEN
+export const OPENCLAW_URL =
+ process.env.OPENCLAW_API_URL ||
+ process.env.OPENCLAW_URL ||
+ 'http://localhost:18789/v1/chat/completions';
+export const OPENCLAW_TOKEN = process.env.OPENCLAW_API_KEY || process.env.OPENCLAW_TOKEN || '';
+
+/**
+ * Get or create conversation history for a channel
+ * @param {string} channelId - Channel ID
+ * @returns {Array} Conversation history
+ */
+export function getHistory(channelId) {
+ if (!conversationHistory.has(channelId)) {
+ conversationHistory.set(channelId, []);
+ }
+ return conversationHistory.get(channelId);
+}
+
+/**
+ * Add message to conversation history
+ * @param {string} channelId - Channel ID
+ * @param {string} role - Message role (user/assistant)
+ * @param {string} content - Message content
+ */
+export function addToHistory(channelId, role, content) {
+ const history = getHistory(channelId);
+ history.push({ role, content });
+
+ // Trim old messages
+ while (history.length > MAX_HISTORY) {
+ history.shift();
+ }
+}
+
+/**
+ * Generate AI response using OpenClaw's chat completions endpoint
+ * @param {string} channelId - Channel ID
+ * @param {string} userMessage - User's message
+ * @param {string} username - Username
+ * @param {Object} config - Bot configuration
+ * @param {Object} healthMonitor - Health monitor instance (optional)
+ * @returns {Promise<string>} AI response
+ */
+export async function generateResponse(
+ channelId,
+ userMessage,
+ username,
+ config,
+ healthMonitor = null,
+) {
+ const history = getHistory(channelId);
+
+ const systemPrompt =
+ config.ai?.systemPrompt ||
+ `You are Volvox Bot, a helpful and friendly Discord bot for the Volvox developer community.
+You're witty, knowledgeable about programming and tech, and always eager to help.
+Keep responses concise and Discord-friendly (under 2000 chars).
+You can use Discord markdown formatting.`;
+
+ // Build messages array for OpenAI-compatible API
+ const messages = [
+ { role: 'system', content: systemPrompt },
+ ...history,
+ { role: 'user', content: `${username}: ${userMessage}` },
+ ];
+
+ // Log incoming AI request
+ info('AI request', { channelId, username, message: userMessage });
+
+ try {
+ const response = await fetch(OPENCLAW_URL, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ ...(OPENCLAW_TOKEN && { Authorization: `Bearer ${OPENCLAW_TOKEN}` }),
+ },
+ body: JSON.stringify({
+ model: config.ai?.model || 'claude-sonnet-4-20250514',
+ max_tokens: config.ai?.maxTokens || 1024,
+ messages: messages,
+ }),
+ });
+
+ if (!response.ok) {
+ if (healthMonitor) {
+ healthMonitor.setAPIStatus('error');
+ }
+ throw new Error(`API error: ${response.status} ${response.statusText}`);
+ }
+
+ const data = await response.json();
+ const reply = data.choices?.[0]?.message?.content || 'I got nothing. Try again?';
+
+ // Log AI response
+ info('AI response', { channelId, username, response: reply.substring(0, 500) });
+
+ // Record successful AI request
+ if (healthMonitor) {
+ healthMonitor.recordAIRequest();
+ healthMonitor.setAPIStatus('ok');
+ }
+
+ // Update history
+ addToHistory(channelId, 'user', `${username}: ${userMessage}`);
+ addToHistory(channelId, 'assistant', reply);
+
+ return reply;
+ } catch (err) {
+ logError('OpenClaw API error', { error: err.message });
+ if (healthMonitor) {
+ healthMonitor.setAPIStatus('error');
+ }
+ return "Sorry, I'm having trouble thinking right now. Try again in a moment!";
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | /**
+ * Chime-In Module
+ * Allows the bot to organically join conversations without being @mentioned.
+ *
+ * How it works:
+ * - Accumulates messages per channel in a ring buffer (capped at maxBufferSize)
+ * - After every `evaluateEvery` messages, asks a cheap LLM: should I chime in?
+ * - If YES → generates a full response via a separate AI context and sends it
+ * - If NO → resets the counter but keeps the buffer for context continuity
+ */
+
+import { info, error as logError, warn } from '../logger.js';
+import { needsSplitting, splitMessage } from '../utils/splitMessage.js';
+import { OPENCLAW_TOKEN, OPENCLAW_URL } from './ai.js';
+
+// ── Per-channel state ──────────────────────────────────────────────────────────
+// Map<channelId, { messages: Array<{author, content}>, counter: number, lastActive: number, abortController: AbortController|null }>
+const channelBuffers = new Map();
+
+// Guard against concurrent evaluations on the same channel
+const evaluatingChannels = new Set();
+
+// LRU eviction settings
+const MAX_TRACKED_CHANNELS = 100;
+const CHANNEL_INACTIVE_MS = 30 * 60 * 1000; // 30 minutes
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+/**
+ * Evict inactive channels from the buffer to prevent unbounded memory growth.
+ */
+function evictInactiveChannels() {
+ const now = Date.now();
+ for (const [channelId, buf] of channelBuffers) {
+ if (now - buf.lastActive > CHANNEL_INACTIVE_MS) {
+ channelBuffers.delete(channelId);
+ }
+ }
+
+ // If still over limit, evict oldest
+ if (channelBuffers.size > MAX_TRACKED_CHANNELS) {
+ const entries = [...channelBuffers.entries()].sort((a, b) => a[1].lastActive - b[1].lastActive);
+ const toEvict = entries.slice(0, channelBuffers.size - MAX_TRACKED_CHANNELS);
+ for (const [channelId] of toEvict) {
+ channelBuffers.delete(channelId);
+ }
+ }
+}
+
+/**
+ * Get or create the buffer state for a channel
+ */
+function getBuffer(channelId) {
+ if (!channelBuffers.has(channelId)) {
+ evictInactiveChannels();
+ channelBuffers.set(channelId, {
+ messages: [],
+ counter: 0,
+ lastActive: Date.now(),
+ abortController: null,
+ });
+ }
+ const buf = channelBuffers.get(channelId);
+ buf.lastActive = Date.now();
+ return buf;
+}
+
+/**
+ * Check whether a channel is eligible for chime-in
+ */
+function isChannelEligible(channelId, chimeInConfig) {
+ const { channels = [], excludeChannels = [] } = chimeInConfig;
+
+ // Explicit exclusion always wins
+ if (excludeChannels.includes(channelId)) return false;
+
+ // Empty allow-list → all channels allowed
+ if (channels.length === 0) return true;
+
+ return channels.includes(channelId);
+}
+
+/**
+ * Call the evaluation LLM (cheap / fast) to decide whether to chime in
+ */
+async function shouldChimeIn(buffer, config, signal) {
+ const chimeInConfig = config.chimeIn || {};
+ const model = chimeInConfig.model || 'claude-haiku-4-5';
+ const systemPrompt = config.ai?.systemPrompt || 'You are a helpful Discord bot.';
+
+ // Format the buffered conversation with structured delimiters to prevent injection
+ const conversationText = buffer.messages.map((m) => `${m.author}: ${m.content}`).join('\n');
+
+ // System instruction first (required by OpenAI-compatible proxies for Anthropic models)
+ const messages = [
+ {
+ role: 'system',
+ content: `You have the following personality:\n${systemPrompt}\n\nYou're monitoring a Discord conversation shown inside <conversation> tags. Based on those messages, could you add something genuinely valuable, interesting, funny, or helpful? Only say YES if a real person would actually want to chime in. Don't chime in just to be present. Reply with only YES or NO.`,
+ },
+ {
+ role: 'user',
+ content: `<conversation>\n${conversationText}\n</conversation>`,
+ },
+ ];
+
+ try {
+ const fetchSignal = signal
+ ? AbortSignal.any([signal, AbortSignal.timeout(10_000)])
+ : AbortSignal.timeout(10_000);
+
+ const response = await fetch(OPENCLAW_URL, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ ...(OPENCLAW_TOKEN && { Authorization: `Bearer ${OPENCLAW_TOKEN}` }),
+ },
+ body: JSON.stringify({
+ model,
+ max_tokens: 10,
+ messages,
+ }),
+ signal: fetchSignal,
+ });
+
+ if (!response.ok) {
+ warn('ChimeIn evaluation API error', { status: response.status });
+ return false;
+ }
+
+ const data = await response.json();
+ const reply = (data.choices?.[0]?.message?.content || '').trim().toUpperCase();
+ info('ChimeIn evaluation result', { reply, model });
+ return reply.startsWith('YES');
+ } catch (err) {
+ logError('ChimeIn evaluation failed', { error: err.message });
+ return false;
+ }
+}
+
+/**
+ * Generate a chime-in response using a separate context (not shared AI history).
+ * This avoids polluting the main conversation history used by @mention responses.
+ */
+async function generateChimeInResponse(buffer, config, signal) {
+ const systemPrompt = config.ai?.systemPrompt || 'You are a helpful Discord bot.';
+ const model = config.ai?.model || 'claude-sonnet-4-20250514';
+ const maxTokens = config.ai?.maxTokens || 1024;
+
+ const conversationText = buffer.messages.map((m) => `${m.author}: ${m.content}`).join('\n');
+
+ const messages = [
+ { role: 'system', content: systemPrompt },
+ {
+ role: 'user',
+ content: `[Conversation context — you noticed this discussion and decided to chime in. Respond naturally as if you're joining the conversation organically. Don't announce that you're "chiming in" — just contribute.]\n\n<conversation>\n${conversationText}\n</conversation>`,
+ },
+ ];
+
+ const fetchSignal = signal
+ ? AbortSignal.any([signal, AbortSignal.timeout(30_000)])
+ : AbortSignal.timeout(30_000);
+
+ const response = await fetch(OPENCLAW_URL, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ ...(OPENCLAW_TOKEN && { Authorization: `Bearer ${OPENCLAW_TOKEN}` }),
+ },
+ body: JSON.stringify({
+ model,
+ max_tokens: maxTokens,
+ messages,
+ }),
+ signal: fetchSignal,
+ });
+
+ if (!response.ok) {
+ throw new Error(`API error: ${response.status} ${response.statusText}`);
+ }
+
+ const data = await response.json();
+ return data.choices?.[0]?.message?.content || '';
+}
+
+// ── Public API ─────────────────────────────────────────────────────────────────
+
+/**
+ * Accumulate a message and potentially trigger a chime-in.
+ * Called from the messageCreate handler for every non-bot guild message.
+ *
+ * @param {Object} message - Discord.js Message object
+ * @param {Object} config - Bot configuration
+ */
+export async function accumulate(message, config) {
+ const chimeInConfig = config.chimeIn;
+ if (!chimeInConfig?.enabled) return;
+ if (!isChannelEligible(message.channel.id, chimeInConfig)) return;
+
+ // Skip empty or attachment-only messages
+ if (!message.content?.trim()) return;
+
+ const channelId = message.channel.id;
+ const buf = getBuffer(channelId);
+ const maxBufferSize = chimeInConfig.maxBufferSize || 30;
+ const evaluateEvery = chimeInConfig.evaluateEvery || 10;
+
+ // Push to ring buffer
+ buf.messages.push({
+ author: message.author.username,
+ content: message.content,
+ });
+
+ // Trim if over cap
+ while (buf.messages.length > maxBufferSize) {
+ buf.messages.shift();
+ }
+
+ // Increment counter
+ buf.counter += 1;
+
+ // Not enough messages yet → bail
+ if (buf.counter < evaluateEvery) return;
+
+ // Prevent concurrent evaluations for the same channel
+ if (evaluatingChannels.has(channelId)) return;
+ evaluatingChannels.add(channelId);
+
+ // Create a new AbortController for this evaluation cycle
+ const abortController = new AbortController();
+ buf.abortController = abortController;
+
+ try {
+ info('ChimeIn evaluating', { channelId, buffered: buf.messages.length, counter: buf.counter });
+
+ const yes = await shouldChimeIn(buf, config, abortController.signal);
+
+ // Check if this evaluation was cancelled (e.g. bot was @mentioned during evaluation)
+ if (abortController.signal.aborted) {
+ info('ChimeIn evaluation cancelled — bot was mentioned or counter reset', { channelId });
+ return;
+ }
+
+ if (yes) {
+ info('ChimeIn triggered — generating response', { channelId });
+
+ await message.channel.sendTyping();
+
+ // Use separate context to avoid polluting shared AI history
+ const response = await generateChimeInResponse(buf, config, abortController.signal);
+
+ // Re-check cancellation after response generation
+ if (abortController.signal.aborted) {
+ info('ChimeIn response suppressed — bot was mentioned during generation', { channelId });
+ return;
+ }
+
+ // Don't send empty/whitespace responses as unsolicited messages
+ if (!response?.trim()) {
+ warn('ChimeIn suppressed empty response', { channelId });
+ } else {
+ // Send as a plain channel message (not a reply)
+ if (needsSplitting(response)) {
+ const chunks = splitMessage(response);
+ for (const chunk of chunks) {
+ await message.channel.send(chunk);
+ }
+ } else {
+ await message.channel.send(response);
+ }
+ }
+
+ // Clear the buffer entirely after a chime-in attempt
+ buf.messages = [];
+ buf.counter = 0;
+ } else {
+ // Reset counter only — keep the buffer for context continuity
+ buf.counter = 0;
+ }
+ } catch (err) {
+ logError('ChimeIn error', { channelId, error: err.message });
+ // Reset counter so we don't spin on errors
+ buf.counter = 0;
+ } finally {
+ evaluatingChannels.delete(channelId);
+ }
+}
+
+/**
+ * Reset the chime-in counter for a channel (call when the bot is @mentioned
+ * so the mention handler doesn't double-fire with a chime-in).
+ *
+ * @param {string} channelId
+ */
+export function resetCounter(channelId) {
+ const buf = channelBuffers.get(channelId);
+ if (buf) {
+ buf.counter = 0;
+
+ // Cancel any in-flight chime-in evaluation to prevent double-responses
+ if (buf.abortController) {
+ buf.abortController.abort();
+ buf.abortController = null;
+ }
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 | + + + + + + + + + + +1x +1x + + +1x + + +1x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +1x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | /**
+ * Configuration Module
+ * Loads config from PostgreSQL with config.json as the seed/fallback
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getPool } from '../db.js';
+import { info, error as logError, warn as logWarn } from '../logger.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const configPath = join(__dirname, '..', '..', 'config.json');
+
+/** @type {Object} In-memory config cache */
+let configCache = {};
+
+/** @type {Object|null} Cached config.json contents (loaded once, never invalidated) */
+let fileConfigCache = null;
+
+/**
+ * Load config.json from disk (used as seed/fallback)
+ * @returns {Object} Configuration object from file
+ * @throws {Error} If config.json is missing or unparseable
+ */
+export function loadConfigFromFile() {
+ if (fileConfigCache) return fileConfigCache;
+
+ if (!existsSync(configPath)) {
+ const err = new Error('config.json not found!');
+ err.code = 'CONFIG_NOT_FOUND';
+ throw err;
+ }
+ try {
+ fileConfigCache = JSON.parse(readFileSync(configPath, 'utf-8'));
+ return fileConfigCache;
+ } catch (err) {
+ throw new Error(`Failed to load config.json: ${err.message}`);
+ }
+}
+
+/**
+ * Load config from PostgreSQL, seeding from config.json if empty
+ * Falls back to config.json if database is unavailable
+ * @returns {Promise<Object>} Configuration object
+ */
+export async function loadConfig() {
+ // Try loading config.json — DB may have valid config even if file is missing
+ let fileConfig;
+ try {
+ fileConfig = loadConfigFromFile();
+ } catch {
+ fileConfig = null;
+ info('config.json not available, will rely on database for configuration');
+ }
+
+ try {
+ let pool;
+ try {
+ pool = getPool();
+ } catch {
+ // DB not initialized — file config is our only option
+ if (!fileConfig) {
+ throw new Error(
+ 'No configuration source available: config.json is missing and database is not initialized',
+ );
+ }
+ info('Database not available, using config.json');
+ configCache = structuredClone(fileConfig);
+ return configCache;
+ }
+
+ // Check if config table has any rows
+ const { rows } = await pool.query('SELECT key, value FROM config');
+
+ if (rows.length === 0) {
+ if (!fileConfig) {
+ throw new Error(
+ 'No configuration source available: database is empty and config.json is missing',
+ );
+ }
+ // Seed database from config.json inside a transaction
+ info('No config in database, seeding from config.json');
+ const client = await pool.connect();
+ try {
+ await client.query('BEGIN');
+ for (const [key, value] of Object.entries(fileConfig)) {
+ await client.query(
+ 'INSERT INTO config (key, value) VALUES ($1, $2) ON CONFLICT (key) DO UPDATE SET value = $2, updated_at = NOW()',
+ [key, JSON.stringify(value)],
+ );
+ }
+ await client.query('COMMIT');
+ info('Config seeded to database');
+ configCache = structuredClone(fileConfig);
+ } catch (txErr) {
+ try {
+ await client.query('ROLLBACK');
+ } catch {
+ /* ignore rollback failure */
+ }
+ throw txErr;
+ } finally {
+ client.release();
+ }
+ } else {
+ // Load from database
+ configCache = {};
+ for (const row of rows) {
+ configCache[row.key] = row.value;
+ }
+ info('Config loaded from database');
+ }
+ } catch (err) {
+ if (!fileConfig) {
+ // No fallback available — re-throw
+ throw err;
+ }
+ logError('Failed to load config from database, using config.json', { error: err.message });
+ configCache = structuredClone(fileConfig);
+ }
+
+ return configCache;
+}
+
+/**
+ * Get the current config (from cache)
+ * @returns {Object} Configuration object
+ */
+export function getConfig() {
+ return configCache;
+}
+
+/**
+ * Set a config value using dot notation (e.g., "ai.model" or "welcome.enabled")
+ * Persists to database and updates in-memory cache
+ * @param {string} path - Dot-notation path (e.g., "ai.model")
+ * @param {*} value - Value to set (automatically parsed from string)
+ * @returns {Promise<Object>} Updated section config
+ */
+export async function setConfigValue(path, value) {
+ const parts = path.split('.');
+ if (parts.length < 2) {
+ throw new Error('Path must include section and key (e.g., "ai.model")');
+ }
+
+ // Reject dangerous keys to prevent prototype pollution
+ validatePathSegments(parts);
+
+ const section = parts[0];
+ const nestedParts = parts.slice(1);
+ const parsedVal = parseValue(value);
+
+ // Deep clone the section for the INSERT case (new section that doesn't exist yet)
+ const sectionClone = structuredClone(configCache[section] || {});
+ setNestedValue(sectionClone, nestedParts, parsedVal);
+
+ // Write to database first, then update cache.
+ // Uses a transaction with row lock to prevent concurrent writes from clobbering.
+ // Reads the current row, applies the change in JS (handles arbitrary nesting),
+ // then writes back — safe because the row is locked for the duration.
+ let dbPersisted = false;
+
+ // Separate pool acquisition from transaction work so we can distinguish
+ // "DB not configured" (graceful fallback) from real transaction errors (must surface).
+ let pool;
+ try {
+ pool = getPool();
+ } catch {
+ // DB not initialized — skip persistence, fall through to in-memory update
+ logWarn('Database not initialized for config write — updating in-memory only');
+ }
+
+ if (pool) {
+ const client = await pool.connect();
+ try {
+ await client.query('BEGIN');
+ // Lock the row (or prepare for INSERT if missing)
+ const { rows } = await client.query('SELECT value FROM config WHERE key = $1 FOR UPDATE', [
+ section,
+ ]);
+
+ if (rows.length > 0) {
+ // Row exists — merge change into the live DB value
+ const dbSection = rows[0].value;
+ setNestedValue(dbSection, nestedParts, parsedVal);
+
+ await client.query('UPDATE config SET value = $1, updated_at = NOW() WHERE key = $2', [
+ JSON.stringify(dbSection),
+ section,
+ ]);
+ } else {
+ // New section — use ON CONFLICT to handle concurrent inserts safely
+ await client.query(
+ 'INSERT INTO config (key, value) VALUES ($1, $2) ON CONFLICT (key) DO UPDATE SET value = $2, updated_at = NOW()',
+ [section, JSON.stringify(sectionClone)],
+ );
+ }
+ await client.query('COMMIT');
+ dbPersisted = true;
+ } catch (txErr) {
+ try {
+ await client.query('ROLLBACK');
+ } catch {
+ /* ignore rollback failure */
+ }
+ throw txErr;
+ } finally {
+ client.release();
+ }
+ }
+
+ // Update in-memory cache (mutate in-place for reference propagation)
+ if (
+ !configCache[section] ||
+ typeof configCache[section] !== 'object' ||
+ Array.isArray(configCache[section])
+ ) {
+ configCache[section] = {};
+ }
+ setNestedValue(configCache[section], nestedParts, parsedVal);
+
+ info('Config updated', { path, value: parsedVal, persisted: dbPersisted });
+ return configCache[section];
+}
+
+/**
+ * Reset a config section to config.json defaults
+ * @param {string} [section] - Section to reset, or all if omitted
+ * @returns {Promise<Object>} Reset config
+ */
+export async function resetConfig(section) {
+ let fileConfig;
+ try {
+ fileConfig = loadConfigFromFile();
+ } catch {
+ throw new Error(
+ 'Cannot reset configuration: config.json is not available. ' +
+ 'Reset requires the default config file as a baseline.',
+ );
+ }
+
+ let pool = null;
+ try {
+ pool = getPool();
+ } catch {
+ logWarn('Database unavailable for config reset — updating in-memory only');
+ }
+
+ if (section) {
+ if (!fileConfig[section]) {
+ throw new Error(`Section '${section}' not found in config.json defaults`);
+ }
+
+ if (pool) {
+ try {
+ await pool.query(
+ 'INSERT INTO config (key, value) VALUES ($1, $2) ON CONFLICT (key) DO UPDATE SET value = $2, updated_at = NOW()',
+ [section, JSON.stringify(fileConfig[section])],
+ );
+ } catch (err) {
+ logError('Database error during section reset — updating in-memory only', {
+ section,
+ error: err.message,
+ });
+ }
+ }
+
+ // Mutate in-place so references stay valid (deep clone to avoid shared refs)
+ const sectionData = configCache[section];
+ if (sectionData && typeof sectionData === 'object' && !Array.isArray(sectionData)) {
+ for (const key of Object.keys(sectionData)) delete sectionData[key];
+ Object.assign(sectionData, structuredClone(fileConfig[section]));
+ } else {
+ configCache[section] = isPlainObject(fileConfig[section])
+ ? structuredClone(fileConfig[section])
+ : fileConfig[section];
+ }
+ info('Config section reset', { section });
+ } else {
+ // Reset all inside a transaction
+ if (pool) {
+ const client = await pool.connect();
+ try {
+ await client.query('BEGIN');
+ for (const [key, value] of Object.entries(fileConfig)) {
+ await client.query(
+ 'INSERT INTO config (key, value) VALUES ($1, $2) ON CONFLICT (key) DO UPDATE SET value = $2, updated_at = NOW()',
+ [key, JSON.stringify(value)],
+ );
+ }
+ // Remove stale keys that exist in DB but not in config.json
+ const fileKeys = Object.keys(fileConfig);
+ if (fileKeys.length > 0) {
+ await client.query('DELETE FROM config WHERE key != ALL($1::text[])', [fileKeys]);
+ }
+ await client.query('COMMIT');
+ } catch (txErr) {
+ try {
+ await client.query('ROLLBACK');
+ } catch {
+ /* ignore rollback failure */
+ }
+ logError('Database error during full config reset — updating in-memory only', {
+ error: txErr.message,
+ });
+ } finally {
+ client.release();
+ }
+ }
+
+ // Mutate in-place and remove stale keys from cache (deep clone to avoid shared refs)
+ for (const key of Object.keys(configCache)) {
+ if (!(key in fileConfig)) {
+ delete configCache[key];
+ }
+ }
+ for (const [key, value] of Object.entries(fileConfig)) {
+ if (configCache[key] && isPlainObject(configCache[key]) && isPlainObject(value)) {
+ for (const k of Object.keys(configCache[key])) delete configCache[key][k];
+ Object.assign(configCache[key], structuredClone(value));
+ } else {
+ configCache[key] = isPlainObject(value) ? structuredClone(value) : value;
+ }
+ }
+ info('All config reset to defaults');
+ }
+
+ return configCache;
+}
+
+/** Keys that must never be used as path segments (prototype pollution vectors) */
+const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+
+/**
+ * Validate that no path segment is a prototype-pollution vector.
+ * @param {string[]} segments - Path segments to check
+ * @throws {Error} If any segment is a dangerous key
+ */
+function validatePathSegments(segments) {
+ for (const segment of segments) {
+ if (DANGEROUS_KEYS.has(segment)) {
+ throw new Error(`Invalid config path: '${segment}' is a reserved key and cannot be used`);
+ }
+ }
+}
+
+/**
+ * Traverse a nested object along dot-notation path segments, creating
+ * intermediate objects as needed, and set the leaf value.
+ * @param {Object} root - Object to traverse
+ * @param {string[]} pathParts - Path segments (excluding the root key)
+ * @param {*} value - Value to set at the leaf
+ */
+function setNestedValue(root, pathParts, value) {
+ if (pathParts.length === 0) {
+ throw new Error('setNestedValue requires at least one path segment');
+ }
+ let current = root;
+ for (let i = 0; i < pathParts.length - 1; i++) {
+ // Defensive: reject prototype-pollution keys even for internal callers
+ if (DANGEROUS_KEYS.has(pathParts[i])) {
+ throw new Error(`Invalid config path segment: '${pathParts[i]}' is a reserved key`);
+ }
+ if (current[pathParts[i]] == null || typeof current[pathParts[i]] !== 'object') {
+ current[pathParts[i]] = {};
+ } else if (Array.isArray(current[pathParts[i]])) {
+ // Keep arrays intact when the next path segment is a valid numeric index;
+ // otherwise replace with a plain object (legacy behaviour for non-numeric keys).
+ if (!/^\d+$/.test(pathParts[i + 1])) {
+ current[pathParts[i]] = {};
+ }
+ }
+ current = current[pathParts[i]];
+ }
+ const leafKey = pathParts[pathParts.length - 1];
+ if (DANGEROUS_KEYS.has(leafKey)) {
+ throw new Error(`Invalid config path segment: '${leafKey}' is a reserved key`);
+ }
+ current[leafKey] = value;
+}
+
+/**
+ * Check if a value is a plain object (not null, not array)
+ * @param {*} val - Value to check
+ * @returns {boolean} True if plain object
+ */
+function isPlainObject(val) {
+ return typeof val === 'object' && val !== null && !Array.isArray(val);
+}
+
+/**
+ * Parse a string value into its appropriate JS type.
+ *
+ * Coercion rules:
+ * - "true" / "false" → boolean
+ * - "null" → null
+ * - Numeric strings → number (unless beyond Number.MAX_SAFE_INTEGER)
+ * - JSON arrays/objects → parsed value
+ * - Everything else → kept as-is string
+ *
+ * To force a literal string (e.g. the word "true"), wrap it in JSON quotes:
+ * "\"true\"" → parsed by JSON.parse into the string "true"
+ *
+ * @param {string} value - String value to parse
+ * @returns {*} Parsed value
+ */
+function parseValue(value) {
+ if (typeof value !== 'string') return value;
+
+ // Booleans
+ if (value === 'true') return true;
+ if (value === 'false') return false;
+
+ // Null
+ if (value === 'null') return null;
+
+ // Numbers (keep as string if beyond safe integer range to avoid precision loss)
+ // Matches: 123, -123, 1.5, -1.5, 1., .5, -.5
+ if (/^-?(\d+\.?\d*|\.\d+)$/.test(value)) {
+ const num = Number(value);
+ if (!Number.isFinite(num)) return value;
+ if (!value.includes('.') && !Number.isSafeInteger(num)) return value;
+ return num;
+ }
+
+ // JSON strings (e.g. "\"true\"" → force literal string "true"), arrays, and objects
+ if (
+ (value.startsWith('"') && value.endsWith('"')) ||
+ (value.startsWith('[') && value.endsWith(']')) ||
+ (value.startsWith('{') && value.endsWith('}'))
+ ) {
+ try {
+ return JSON.parse(value);
+ } catch {
+ return value;
+ }
+ }
+
+ // Plain string
+ return value;
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | /**
+ * Events Module
+ * Handles Discord event listeners and handlers
+ */
+
+import { error as logError, info, warn } from '../logger.js';
+import { needsSplitting, splitMessage } from '../utils/splitMessage.js';
+import { generateResponse } from './ai.js';
+import { accumulate, resetCounter } from './chimeIn.js';
+import { isSpam, sendSpamAlert } from './spam.js';
+import { recordCommunityActivity, sendWelcomeMessage } from './welcome.js';
+
+/**
+ * Register bot ready event handler
+ * @param {Object} client - Discord client
+ * @param {Object} config - Bot configuration
+ * @param {Object} healthMonitor - Health monitor instance
+ */
+export function registerReadyHandler(client, config, healthMonitor) {
+ client.once('clientReady', () => {
+ info(`${client.user.tag} is online`, { servers: client.guilds.cache.size });
+
+ // Record bot start time
+ if (healthMonitor) {
+ healthMonitor.recordStart();
+ }
+
+ if (config.welcome?.enabled) {
+ info('Welcome messages enabled', { channelId: config.welcome.channelId });
+ }
+ if (config.ai?.enabled) {
+ info('AI chat enabled', { model: config.ai.model || 'claude-sonnet-4-20250514' });
+ }
+ if (config.moderation?.enabled) {
+ info('Moderation enabled');
+ }
+ });
+}
+
+/**
+ * Register guild member add event handler
+ * @param {Object} client - Discord client
+ * @param {Object} config - Bot configuration
+ */
+export function registerGuildMemberAddHandler(client, config) {
+ client.on('guildMemberAdd', async (member) => {
+ await sendWelcomeMessage(member, client, config);
+ });
+}
+
+/**
+ * Register message create event handler
+ * @param {Object} client - Discord client
+ * @param {Object} config - Bot configuration
+ * @param {Object} healthMonitor - Health monitor instance
+ */
+export function registerMessageCreateHandler(client, config, healthMonitor) {
+ client.on('messageCreate', async (message) => {
+ // Ignore bots and DMs
+ if (message.author.bot) return;
+ if (!message.guild) return;
+
+ // Spam detection
+ if (config.moderation?.enabled && isSpam(message.content)) {
+ warn('Spam detected', { user: message.author.tag, content: message.content.slice(0, 50) });
+ await sendSpamAlert(message, client, config);
+ return;
+ }
+
+ // Feed welcome-context activity tracker
+ recordCommunityActivity(message, config);
+
+ // AI chat - respond when mentioned (checked BEFORE accumulate to prevent double responses)
+ if (config.ai?.enabled) {
+ const isMentioned = message.mentions.has(client.user);
+ const isReply = message.reference && message.mentions.repliedUser?.id === client.user.id;
+
+ // Check if in allowed channel (if configured)
+ const allowedChannels = config.ai?.channels || [];
+ const isAllowedChannel =
+ allowedChannels.length === 0 || allowedChannels.includes(message.channel.id);
+
+ if ((isMentioned || isReply) && isAllowedChannel) {
+ // Reset chime-in counter so we don't double-respond
+ resetCounter(message.channel.id);
+
+ // Remove the mention from the message
+ const cleanContent = message.content
+ .replace(new RegExp(`<@!?${client.user.id}>`, 'g'), '')
+ .trim();
+
+ if (!cleanContent) {
+ await message.reply("Hey! What's up?");
+ return;
+ }
+
+ await message.channel.sendTyping();
+
+ const response = await generateResponse(
+ message.channel.id,
+ cleanContent,
+ message.author.username,
+ config,
+ healthMonitor,
+ );
+
+ // Split long responses
+ if (needsSplitting(response)) {
+ const chunks = splitMessage(response);
+ for (const chunk of chunks) {
+ await message.channel.send(chunk);
+ }
+ } else {
+ await message.reply(response);
+ }
+
+ return; // Don't accumulate direct mentions into chime-in buffer
+ }
+ }
+
+ // Chime-in: accumulate message for organic participation (fire-and-forget)
+ accumulate(message, config).catch((err) => {
+ logError('ChimeIn accumulate error', { error: err.message });
+ });
+ });
+}
+
+/**
+ * Register error event handlers
+ * @param {Object} client - Discord client
+ */
+export function registerErrorHandlers(client) {
+ client.on('error', (err) => {
+ logError('Discord error', { error: err.message, stack: err.stack });
+ });
+
+ process.on('unhandledRejection', (err) => {
+ logError('Unhandled rejection', { error: err?.message, stack: err?.stack });
+ });
+}
+
+/**
+ * Register all event handlers
+ * @param {Object} client - Discord client
+ * @param {Object} config - Bot configuration
+ * @param {Object} healthMonitor - Health monitor instance
+ */
+export function registerEventHandlers(client, config, healthMonitor) {
+ registerReadyHandler(client, config, healthMonitor);
+ registerGuildMemberAddHandler(client, config);
+ registerMessageCreateHandler(client, config, healthMonitor);
+ registerErrorHandlers(client);
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| ai.js | +
+
+ |
+ 100% | +36/36 | +96.29% | +26/27 | +100% | +5/5 | +100% | +36/36 | +
| chimeIn.js | +
+
+ |
+ 0% | +0/110 | +0% | +0/68 | +0% | +0/10 | +0% | +0/100 | +
| config.js | +
+
+ |
+ 2.85% | +5/175 | +0% | +0/94 | +0% | +0/9 | +3.03% | +5/165 | +
| events.js | +
+
+ |
+ 0% | +0/51 | +0% | +0/35 | +0% | +0/11 | +0% | +0/49 | +
| spam.js | +
+
+ |
+ 100% | +13/13 | +100% | +8/8 | +100% | +5/5 | +100% | +10/10 | +
| welcome.js | +
+
+ |
+ 50.89% | +85/167 | +36.18% | +55/152 | +29.72% | +11/37 | +51.67% | +77/149 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 | + + + + + + + +1x + + + + + + + + + + + + + + + + + +155x + + + + + + + + + +16x + +15x + +1x +15x + +13x + + + + + + + + + + +16x + + +13x +2x + + + | /**
+ * Spam Detection Module
+ * Handles spam/scam detection and moderation
+ */
+
+import { EmbedBuilder } from 'discord.js';
+
+// Spam patterns
+const SPAM_PATTERNS = [
+ /free\s*(crypto|bitcoin|btc|eth|nft)/i,
+ /airdrop.*claim/i,
+ /discord\s*nitro\s*free/i,
+ /nitro\s*gift.*claim/i,
+ /click.*verify.*account/i,
+ /guaranteed.*profit/i,
+ /invest.*double.*money/i,
+ /dm\s*me\s*for.*free/i,
+ /make\s*\$?\d+k?\+?\s*(daily|weekly|monthly)/i,
+];
+
+/**
+ * Check if message content is spam
+ * @param {string} content - Message content to check
+ * @returns {boolean} True if spam detected
+ */
+export function isSpam(content) {
+ return SPAM_PATTERNS.some((pattern) => pattern.test(content));
+}
+
+/**
+ * Send spam alert to moderation channel
+ * @param {Object} message - Discord message object
+ * @param {Object} client - Discord client
+ * @param {Object} config - Bot configuration
+ */
+export async function sendSpamAlert(message, client, config) {
+ if (!config.moderation?.alertChannelId) return;
+
+ const alertChannel = await client.channels
+ .fetch(config.moderation.alertChannelId)
+ .catch(() => null);
+ if (!alertChannel) return;
+
+ const embed = new EmbedBuilder()
+ .setColor(0xff6b6b)
+ .setTitle('⚠️ Potential Spam Detected')
+ .addFields(
+ { name: 'Author', value: `<@${message.author.id}>`, inline: true },
+ { name: 'Channel', value: `<#${message.channel.id}>`, inline: true },
+ { name: 'Content', value: message.content.slice(0, 1000) || '*empty*' },
+ { name: 'Link', value: `[Jump](${message.url})` },
+ )
+ .setTimestamp();
+
+ await alertChannel.send({ embeds: [embed] });
+
+ // Auto-delete if enabled
+ if (config.moderation?.autoDelete) {
+ await message.delete().catch(() => {});
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 | + + + + + + +1x +1x +1x + + +1x + + +1x + + + + + + + + + +14x + + + + + + + + + + + + + +11x +9x + +8x +11x +11x +11x +3x + +8x + +7x +7x +7x + +7x +1x + + +7x +7x + +11x +11x + + +7x + + + +7x + + + + + + + + + +18x + +16x +16x +15x + +14x + +18x + + + + + + + +18x +5x + +10x + + + + + + + + + + +8x +8x + +8x + + + + + + +8x +8x +8x +8x + +8x +8x +8x + +8x + +8x + + + + + + + + + + + + + + + + + + +8x +8x +8x +8x + +8x +8x + +8x +56x + +16x + + + + + +16x + +16x +16x + + + +8x + + + +8x +8x + +16x + +8x + + + +8x +8x + + + + +8x + +8x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +8x + +8x +2x + + + + + + + + + + +8x +8x + + + + + +8x +8x + +1x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +15x +15x + + + + + + + + + + + + + + | /**
+ * Welcome Module
+ * Handles dynamic welcome messages for new members
+ */
+
+import { error as logError, info } from '../logger.js';
+
+const guildActivity = new Map();
+const DEFAULT_ACTIVITY_WINDOW_MINUTES = 45;
+const MAX_EVENTS_PER_CHANNEL = 250;
+
+/** Notable member-count milestones (hoisted to avoid allocation per welcome event) */
+const NOTABLE_MILESTONES = new Set([10, 25, 50, 100, 250, 500, 1000]);
+
+/** @type {{key: string, set: Set<string>} | null} Cached excluded channels Set */
+let excludedChannelsCache = null;
+
+/**
+ * Render welcome message with placeholder replacements
+ * @param {string} messageTemplate - Welcome message template
+ * @param {Object} member - Member object with id and optional username
+ * @param {Object} guild - Guild object with name and memberCount
+ * @returns {string} Rendered welcome message
+ */
+export function renderWelcomeMessage(messageTemplate, member, guild) {
+ return messageTemplate
+ .replace(/{user}/g, `<@${member.id}>`)
+ .replace(/{username}/g, member.username || 'Unknown')
+ .replace(/{server}/g, guild.name)
+ .replace(/{memberCount}/g, guild.memberCount.toString());
+}
+
+/**
+ * Track message activity for welcome context.
+ * Called from messageCreate handler to build a live community pulse.
+ * @param {Object} message - Discord message
+ * @param {Object} config - Bot configuration
+ */
+export function recordCommunityActivity(message, config) {
+ if (!message?.guild || !message?.channel || message.author?.bot) return;
+ if (!message.channel?.isTextBased?.()) return;
+
+ const welcomeDynamic = config?.welcome?.dynamic || {};
+ const excludeList = welcomeDynamic.excludeChannels || [];
+ const cacheKey = excludeList.join(',');
+ if (!excludedChannelsCache || excludedChannelsCache.key !== cacheKey) {
+ excludedChannelsCache = { key: cacheKey, set: new Set(excludeList) };
+ }
+ if (excludedChannelsCache.set.has(message.channel.id)) return;
+
+ const now = Date.now();
+ const windowMs = getActivityWindowMs(welcomeDynamic);
+ const cutoff = now - windowMs;
+
+ if (!guildActivity.has(message.guild.id)) {
+ guildActivity.set(message.guild.id, new Map());
+ }
+
+ const activityMap = guildActivity.get(message.guild.id);
+ const timestamps = activityMap.get(message.channel.id) || [];
+
+ timestamps.push(now);
+ while (timestamps.length && timestamps[0] < cutoff) {
+ timestamps.shift();
+ }
+ Iif (timestamps.length > MAX_EVENTS_PER_CHANNEL) {
+ timestamps.splice(0, timestamps.length - MAX_EVENTS_PER_CHANNEL);
+ }
+
+ activityMap.set(message.channel.id, timestamps);
+}
+
+/**
+ * Send welcome message to new member
+ * @param {Object} member - Discord guild member
+ * @param {Object} client - Discord client
+ * @param {Object} config - Bot configuration
+ */
+export async function sendWelcomeMessage(member, client, config) {
+ if (!config.welcome?.enabled || !config.welcome?.channelId) return;
+
+ try {
+ const channel = await client.channels.fetch(config.welcome.channelId);
+ if (!channel) return;
+
+ const useDynamic = config.welcome?.dynamic?.enabled === true;
+
+ const message = useDynamic
+ ? buildDynamicWelcomeMessage(member, config)
+ : renderWelcomeMessage(
+ config.welcome.message || 'Welcome, {user}!',
+ { id: member.id, username: member.user.username },
+ { name: member.guild.name, memberCount: member.guild.memberCount },
+ );
+
+ await channel.send(message);
+ info('Welcome message sent', { user: member.user.tag, guild: member.guild.name });
+ } catch (err) {
+ logError('Welcome error', { error: err.message });
+ }
+}
+
+/**
+ * Build contextual welcome message based on time, activity, and milestones.
+ * @param {Object} member - Discord guild member
+ * @param {Object} config - Bot configuration
+ * @returns {string} Dynamic welcome message
+ */
+function buildDynamicWelcomeMessage(member, config) {
+ const welcomeDynamic = config?.welcome?.dynamic || {};
+ const timezone = welcomeDynamic.timezone || 'America/New_York';
+
+ const memberContext = {
+ id: member.id,
+ username: member.user?.username || 'Unknown',
+ server: member.guild?.name || 'the server',
+ memberCount: member.guild?.memberCount || 0,
+ };
+
+ const timeOfDay = getTimeOfDay(timezone);
+ const snapshot = getCommunitySnapshot(member.guild, welcomeDynamic);
+ const milestoneLine = getMilestoneLine(memberContext.memberCount, welcomeDynamic);
+ const suggestedChannels = getSuggestedChannels(member, config, snapshot);
+
+ const greeting = pickFrom(getGreetingTemplates(timeOfDay), memberContext);
+ const vibeLine = buildVibeLine(snapshot, suggestedChannels);
+ const ctaLine = buildCtaLine(suggestedChannels);
+
+ const lines = [greeting];
+
+ if (milestoneLine) {
+ lines.push(milestoneLine);
+ } else {
+ lines.push(`You just rolled in as member **#${memberContext.memberCount}**.`);
+ }
+
+ lines.push(vibeLine);
+ lines.push(ctaLine);
+
+ return lines.join('\n\n');
+}
+
+/**
+ * Get activity snapshot for the guild.
+ * @param {Object} guild - Discord guild
+ * @param {Object} settings - welcome.dynamic settings
+ * @returns {{messageCount:number,activeTextChannels:number,topChannelIds:string[],voiceParticipants:number,voiceChannels:number,level:string}}
+ */
+function getCommunitySnapshot(guild, settings) {
+ const activityMap = guildActivity.get(guild.id) || new Map();
+ const now = Date.now();
+ const windowMs = getActivityWindowMs(settings);
+ const cutoff = now - windowMs;
+
+ let messageCount = 0;
+ const channelCounts = [];
+
+ for (const [channelId, timestamps] of activityMap.entries()) {
+ const recent = timestamps.filter((t) => t >= cutoff);
+
+ Iif (!recent.length) {
+ activityMap.delete(channelId);
+ continue;
+ }
+
+ // Write the pruned array back so stale entries don't accumulate forever
+ activityMap.set(channelId, recent);
+
+ messageCount += recent.length;
+ channelCounts.push({ channelId, count: recent.length });
+ }
+
+ // Evict guild entry if no channels remain
+ Iif (activityMap.size === 0) {
+ guildActivity.delete(guild.id);
+ }
+
+ const topChannelIds = channelCounts
+ .sort((a, b) => b.count - a.count)
+ .slice(0, 3)
+ .map((entry) => entry.channelId);
+
+ const activeVoiceChannels = guild.channels.cache.filter(
+ (channel) => channel?.isVoiceBased?.() && channel.members?.size > 0,
+ );
+
+ const voiceChannels = activeVoiceChannels.size;
+ const voiceParticipants = [...activeVoiceChannels.values()].reduce(
+ (sum, channel) => sum + (channel.members?.size || 0),
+ 0,
+ );
+
+ const level = getActivityLevel(messageCount, voiceParticipants);
+
+ return {
+ messageCount,
+ activeTextChannels: channelCounts.length,
+ topChannelIds,
+ voiceParticipants,
+ voiceChannels,
+ level,
+ };
+}
+
+/**
+ * Get activity level from message + voice activity.
+ * @param {number} messageCount - Messages in rolling window
+ * @param {number} voiceParticipants - Active users in voice channels
+ * @returns {'quiet'|'light'|'steady'|'busy'|'hype'}
+ */
+function getActivityLevel(messageCount, voiceParticipants) {
+ if (messageCount >= 60 || voiceParticipants >= 15) return 'hype';
+ if (messageCount >= 25 || voiceParticipants >= 8) return 'busy';
+ if (messageCount >= 8 || voiceParticipants >= 3) return 'steady';
+ if (messageCount >= 1 || voiceParticipants >= 1) return 'light';
+ return 'quiet';
+}
+
+/**
+ * Build vibe line from current community activity.
+ * @param {Object} snapshot - Community snapshot
+ * @param {string[]} suggestedChannels - Channel mentions
+ * @returns {string}
+ */
+function buildVibeLine(snapshot, suggestedChannels) {
+ const topChannels = snapshot.topChannelIds.map((id) => `<#${id}>`);
+ const channelList = (topChannels.length ? topChannels : suggestedChannels).slice(0, 2);
+ const channelText = channelList.join(' + ');
+ const hasChannels = channelList.length > 0;
+
+ switch (snapshot.level) {
+ case 'hype':
+ return hasChannels
+ ? `The place is buzzing right now - big energy in ${channelText}.`
+ : `The place is buzzing right now - big energy everywhere.`;
+ case 'busy':
+ return hasChannels
+ ? `Good timing: chat is active (${snapshot.messageCount} messages recently), especially in ${channelText}.`
+ : `Good timing: the server is active right now (${snapshot.messageCount} messages recently${snapshot.voiceParticipants > 0 ? `, ${snapshot.voiceParticipants} in voice` : ''}).`;
+ case 'steady':
+ return hasChannels
+ ? `Things are moving at a healthy pace in ${channelText}, so you'll fit right in.`
+ : `Things are moving at a healthy pace, so you'll fit right in.`;
+ case 'light':
+ if (snapshot.voiceChannels > 0 && !hasChannels) {
+ return `${snapshot.voiceParticipants} ${snapshot.voiceParticipants === 1 ? 'person is' : 'people are'} hanging out in voice right now — jump in anytime.`;
+ }
+ if (snapshot.voiceChannels > 0) {
+ return `${snapshot.voiceParticipants} ${snapshot.voiceParticipants === 1 ? 'person is' : 'people are'} hanging out in voice right now, and ${channelText} is waking up.`;
+ }
+ return hasChannels
+ ? `It's a chill moment, but ${channelText} is where people are checking in.`
+ : `It's a chill moment — perfect time to say hello.`;
+ default:
+ return `You're catching us in a quiet window - perfect time to introduce yourself before the chaos starts.`;
+ }
+}
+
+/**
+ * Build CTA line with channel suggestions.
+ * @param {string[]} channels - Channel mentions
+ * @returns {string}
+ */
+function buildCtaLine(channels) {
+ const [first, second, third] = channels;
+
+ if (first && second && third) {
+ return `Start in ${first}, share what you're building in ${second}, and lurk project updates in ${third}.`;
+ }
+ if (first && second) {
+ return `Drop a quick intro in ${first} and show off what you're building in ${second}.`;
+ }
+ if (first) {
+ return `Say hey in ${first} and let us know what you're building.`;
+ }
+
+ return "Say hey and tell us what you're building — we're glad you're here.";
+}
+
+/**
+ * Build milestone line when member count hits notable threshold.
+ * @param {number} memberCount - Current member count
+ * @param {Object} settings - welcome.dynamic settings
+ * @returns {string|null}
+ */
+function getMilestoneLine(memberCount, settings) {
+ if (!memberCount) return null;
+
+ const interval = Number(settings.milestoneInterval) || 25;
+
+ if (NOTABLE_MILESTONES.has(memberCount) || (interval > 0 && memberCount % interval === 0)) {
+ return `🎉 Perfect timing - you're our **#${memberCount}** member milestone!`;
+ }
+
+ return null;
+}
+
+/**
+ * Determine time of day for greeting.
+ * @param {string} timezone - IANA timezone
+ * @returns {'morning'|'afternoon'|'evening'|'night'}
+ */
+function getTimeOfDay(timezone) {
+ const hour = getHourInTimezone(timezone);
+
+ if (hour >= 5 && hour < 12) return 'morning';
+ Eif (hour >= 12 && hour < 17) return 'afternoon';
+ if (hour >= 17 && hour < 22) return 'evening';
+ return 'night';
+}
+
+/**
+ * Get hour in timezone.
+ * @param {string} timezone - IANA timezone
+ * @returns {number}
+ */
+function getHourInTimezone(timezone) {
+ try {
+ const hourString = new Intl.DateTimeFormat('en-US', {
+ hour: '2-digit',
+ hour12: false,
+ timeZone: timezone,
+ }).format(new Date());
+
+ const hour = Number(hourString);
+ return Number.isFinite(hour) ? hour : new Date().getHours();
+ } catch {
+ return new Date().getHours();
+ }
+}
+
+/**
+ * Get greeting templates by time of day.
+ * @param {'morning'|'afternoon'|'evening'|'night'} timeOfDay - Time context
+ * @returns {Array<(ctx:Object)=>string>}
+ */
+function getGreetingTemplates(timeOfDay) {
+ const templates = {
+ morning: [
+ (ctx) => `☀️ Morning and welcome to **${ctx.server}**, <@${ctx.id}>!`,
+ (ctx) => `Hey <@${ctx.id}> - great way to start the day. Welcome to **${ctx.server}**!`,
+ (ctx) => `Good morning <@${ctx.id}> 👋 You just joined **${ctx.server}**.`,
+ ],
+ afternoon: [
+ (ctx) => `👋 Welcome to **${ctx.server}**, <@${ctx.id}>!`,
+ (ctx) =>
+ `Nice timing, <@${ctx.id}> - welcome to the **${ctx.server}** corner of the internet.`,
+ (ctx) => `Hey <@${ctx.id}>! Glad you made it into **${ctx.server}**.`,
+ ],
+ evening: [
+ (ctx) => `🌆 Evening crew just got better - welcome, <@${ctx.id}>!`,
+ (ctx) => `Welcome to **${ctx.server}**, <@${ctx.id}>. Prime build-hours energy right now.`,
+ (ctx) => `Hey <@${ctx.id}> 👋 Great time to join the party at **${ctx.server}**.`,
+ ],
+ night: [
+ (ctx) => `🌙 Night owl spotted. Welcome to **${ctx.server}**, <@${ctx.id}>!`,
+ (ctx) => `Late-night builders are active - welcome in, <@${ctx.id}>.`,
+ (ctx) => `Welcome <@${ctx.id}>! The night shift at **${ctx.server}** is undefeated.`,
+ ],
+ };
+
+ return templates[timeOfDay] || templates.afternoon;
+}
+
+/**
+ * Pick channels to suggest based on active channels, configured highlights, and legacy template links.
+ * @param {Object} member - Discord guild member
+ * @param {Object} config - Bot configuration
+ * @param {Object} snapshot - Community snapshot
+ * @returns {string[]} Channel mentions
+ */
+function getSuggestedChannels(member, config, snapshot) {
+ const dynamic = config?.welcome?.dynamic || {};
+ const configured = Array.isArray(dynamic.highlightChannels) ? dynamic.highlightChannels : [];
+ const legacy = extractChannelIdsFromTemplate(config?.welcome?.message || '');
+ const top = snapshot.topChannelIds || [];
+
+ const channelIds = [...new Set([...top, ...configured, ...legacy])]
+ .filter(Boolean)
+ .filter((id) => member.guild.channels.cache.has(id))
+ .slice(0, 3);
+
+ return channelIds.map((id) => `<#${id}>`);
+}
+
+/**
+ * Extract channel IDs from legacy message template (<#...> format)
+ * @param {string} template - Legacy welcome template
+ * @returns {string[]} Channel IDs
+ */
+function extractChannelIdsFromTemplate(template) {
+ const matches = template.match(/<#(\d+)>/g) || [];
+ return matches.map((match) => match.replace(/[^\d]/g, ''));
+}
+
+/**
+ * Calculate activity window in ms.
+ * @param {Object} settings - welcome.dynamic settings
+ * @returns {number}
+ */
+function getActivityWindowMs(settings) {
+ const minutes = Number(settings.activityWindowMinutes) || DEFAULT_ACTIVITY_WINDOW_MINUTES;
+ return Math.max(5, minutes) * 60 * 1000;
+}
+
+/**
+ * Pick one function from template list and execute with context.
+ * @param {Array<(ctx:Object)=>string>} templates - Template fns
+ * @param {Object} context - Template context
+ * @returns {string}
+ */
+function pickFrom(templates, context) {
+ if (!templates.length) return `Welcome, <@${context.id}>!`;
+ const index = Math.floor(Math.random() * templates.length);
+ return templates[index](context);
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 | + + + + + + + + + +1x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +51x + +49x +51x +51x + + +51x +7x + +42x +3x + +39x +2x + + + +37x +17x +5x + +12x +4x + +8x +4x + +4x +3x + +1x +1x + + + + +20x +2x + +18x +3x + +15x +2x + + + +13x +5x + +8x +1x + + + +7x +2x + + +5x + + + + + + + + + + +6x + +6x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +6x + + + + + + + + + + +6x + +6x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +6x + + + + + + + + + + +9x + + +9x + + + + + + +9x + + | /**
+ * Error Classification and User-Friendly Messages
+ *
+ * Provides utilities for classifying errors and generating
+ * helpful error messages for users.
+ */
+
+/**
+ * Error type classifications
+ */
+export const ErrorType = {
+ // Network-related errors
+ NETWORK: 'network',
+ TIMEOUT: 'timeout',
+
+ // API errors
+ API_ERROR: 'api_error',
+ API_RATE_LIMIT: 'api_rate_limit',
+ API_UNAUTHORIZED: 'api_unauthorized',
+ API_NOT_FOUND: 'api_not_found',
+ API_SERVER_ERROR: 'api_server_error',
+
+ // Discord-specific errors
+ DISCORD_PERMISSION: 'discord_permission',
+ DISCORD_CHANNEL_NOT_FOUND: 'discord_channel_not_found',
+ DISCORD_MISSING_ACCESS: 'discord_missing_access',
+
+ // Configuration errors
+ CONFIG_MISSING: 'config_missing',
+ CONFIG_INVALID: 'config_invalid',
+
+ // Unknown/generic errors
+ UNKNOWN: 'unknown',
+};
+
+/**
+ * Classify an error into a specific error type
+ *
+ * @param {Error} error - The error to classify
+ * @param {Object} context - Optional context (response, statusCode, etc.)
+ * @returns {string} Error type from ErrorType enum
+ */
+export function classifyError(error, context = {}) {
+ if (!error) return ErrorType.UNKNOWN;
+
+ const message = error.message?.toLowerCase() || '';
+ const code = error.code || context.code;
+ const status = error.status || context.status || context.statusCode;
+
+ // Network errors
+ if (code === 'ECONNREFUSED' || code === 'ENOTFOUND' || code === 'ETIMEDOUT') {
+ return ErrorType.NETWORK;
+ }
+ if (code === 'ETIMEDOUT' || message.includes('timeout')) {
+ return ErrorType.TIMEOUT;
+ }
+ if (message.includes('fetch failed') || message.includes('network')) {
+ return ErrorType.NETWORK;
+ }
+
+ // HTTP status code errors
+ if (status) {
+ if (status === 401 || status === 403) {
+ return ErrorType.API_UNAUTHORIZED;
+ }
+ if (status === 404) {
+ return ErrorType.API_NOT_FOUND;
+ }
+ if (status === 429) {
+ return ErrorType.API_RATE_LIMIT;
+ }
+ if (status >= 500) {
+ return ErrorType.API_SERVER_ERROR;
+ }
+ Eif (status >= 400) {
+ return ErrorType.API_ERROR;
+ }
+ }
+
+ // Discord-specific errors
+ if (code === 50001 || message.includes('missing access')) {
+ return ErrorType.DISCORD_MISSING_ACCESS;
+ }
+ if (code === 50013 || message.includes('missing permissions')) {
+ return ErrorType.DISCORD_PERMISSION;
+ }
+ if (code === 10003 || message.includes('unknown channel')) {
+ return ErrorType.DISCORD_CHANNEL_NOT_FOUND;
+ }
+
+ // Config errors
+ if (message.includes('config.json not found') || message.includes('enoent')) {
+ return ErrorType.CONFIG_MISSING;
+ }
+ if (message.includes('invalid') && message.includes('config')) {
+ return ErrorType.CONFIG_INVALID;
+ }
+
+ // API errors (generic)
+ if (message.includes('api error') || context.isApiError) {
+ return ErrorType.API_ERROR;
+ }
+
+ return ErrorType.UNKNOWN;
+}
+
+/**
+ * Get a user-friendly error message based on error type
+ *
+ * @param {Error} error - The error object
+ * @param {Object} context - Optional context for more specific messages
+ * @returns {string} User-friendly error message
+ */
+export function getUserFriendlyMessage(error, context = {}) {
+ const errorType = classifyError(error, context);
+
+ const messages = {
+ [ErrorType.NETWORK]:
+ "I'm having trouble connecting to my brain right now. Check if the AI service is running and try again!",
+
+ [ErrorType.TIMEOUT]:
+ 'That took too long to process. Try again with a shorter message, or wait a moment and retry!',
+
+ [ErrorType.API_RATE_LIMIT]:
+ "Whoa, too many requests! Let's take a quick breather. Try again in a minute.",
+
+ [ErrorType.API_UNAUTHORIZED]:
+ "I'm having authentication issues with the AI service. An admin needs to check the API credentials.",
+
+ [ErrorType.API_NOT_FOUND]:
+ "The AI service endpoint isn't responding. Please check if it's configured correctly.",
+
+ [ErrorType.API_SERVER_ERROR]:
+ 'The AI service is having technical difficulties. It should recover automatically - try again in a moment!',
+
+ [ErrorType.API_ERROR]:
+ 'Something went wrong with the AI service. Give it another shot in a moment!',
+
+ [ErrorType.DISCORD_PERMISSION]:
+ "I don't have permission to do that! An admin needs to check my role permissions.",
+
+ [ErrorType.DISCORD_CHANNEL_NOT_FOUND]:
+ "I can't find that channel. It might have been deleted, or I don't have access to it.",
+
+ [ErrorType.DISCORD_MISSING_ACCESS]:
+ "I don't have access to that resource. Please check my permissions!",
+
+ [ErrorType.CONFIG_MISSING]:
+ 'Configuration file not found! Please create a config.json file (you can copy from config.example.json).',
+
+ [ErrorType.CONFIG_INVALID]:
+ 'The configuration file has errors. Please check config.json for syntax errors or missing required fields.',
+
+ [ErrorType.UNKNOWN]:
+ 'Something unexpected happened. Try again, and if it keeps happening, check the logs for details.',
+ };
+
+ return messages[errorType] || messages[ErrorType.UNKNOWN];
+}
+
+/**
+ * Get suggested next steps for an error
+ *
+ * @param {Error} error - The error object
+ * @param {Object} context - Optional context
+ * @returns {string|null} Suggested next steps or null if none
+ */
+export function getSuggestedNextSteps(error, context = {}) {
+ const errorType = classifyError(error, context);
+
+ const suggestions = {
+ [ErrorType.NETWORK]: 'Make sure the AI service (OpenClaw) is running and accessible.',
+
+ [ErrorType.TIMEOUT]: 'Try a shorter message or wait a moment before retrying.',
+
+ [ErrorType.API_RATE_LIMIT]: 'Wait 60 seconds before trying again.',
+
+ [ErrorType.API_UNAUTHORIZED]:
+ 'Check the OPENCLAW_API_KEY environment variable (or legacy OPENCLAW_TOKEN) and API credentials.',
+
+ [ErrorType.API_NOT_FOUND]:
+ 'Verify OPENCLAW_API_URL (or legacy OPENCLAW_URL) points to the correct endpoint.',
+
+ [ErrorType.API_SERVER_ERROR]:
+ 'The service should recover automatically. If it persists, restart the AI service.',
+
+ [ErrorType.DISCORD_PERMISSION]:
+ 'Grant the bot appropriate permissions in Server Settings > Roles.',
+
+ [ErrorType.DISCORD_CHANNEL_NOT_FOUND]:
+ 'Update the channel ID in config.json or verify the channel exists.',
+
+ [ErrorType.DISCORD_MISSING_ACCESS]:
+ 'Ensure the bot has access to the required channels and roles.',
+
+ [ErrorType.CONFIG_MISSING]:
+ 'Create config.json from config.example.json and fill in your settings.',
+
+ [ErrorType.CONFIG_INVALID]: 'Validate your config.json syntax using a JSON validator.',
+ };
+
+ return suggestions[errorType] || null;
+}
+
+/**
+ * Check if an error is retryable (transient failure)
+ *
+ * @param {Error} error - The error to check
+ * @param {Object} context - Optional context
+ * @returns {boolean} True if the error should be retried
+ */
+export function isRetryable(error, context = {}) {
+ const errorType = classifyError(error, context);
+
+ // Only retry transient failures, not user/config errors
+ const retryableTypes = [
+ ErrorType.NETWORK,
+ ErrorType.TIMEOUT,
+ ErrorType.API_SERVER_ERROR,
+ ErrorType.API_RATE_LIMIT,
+ ];
+
+ return retryableTypes.includes(errorType);
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | /**
+ * Health Monitor - Tracks bot health metrics
+ *
+ * Monitors:
+ * - Uptime (time since bot started)
+ * - Memory usage
+ * - Last AI request timestamp
+ * - OpenClaw API connectivity status
+ */
+
+/**
+ * Singleton health monitor instance
+ */
+class HealthMonitor {
+ constructor() {
+ if (HealthMonitor.instance) {
+ throw new Error('Use HealthMonitor.getInstance() to obtain the singleton');
+ }
+
+ this.startTime = Date.now();
+ this.lastAIRequest = null;
+ this.apiStatus = 'unknown';
+ this.lastAPICheck = null;
+
+ HealthMonitor.instance = this;
+ }
+
+ /**
+ * Get singleton instance
+ */
+ static getInstance() {
+ if (!HealthMonitor.instance) {
+ HealthMonitor.instance = new HealthMonitor();
+ }
+ return HealthMonitor.instance;
+ }
+
+ /**
+ * Record the start time (call when bot is ready)
+ */
+ recordStart() {
+ this.startTime = Date.now();
+ }
+
+ /**
+ * Record AI request activity
+ */
+ recordAIRequest() {
+ this.lastAIRequest = Date.now();
+ }
+
+ /**
+ * Update API status
+ * @param {string} status - 'ok', 'error', or 'unknown'
+ */
+ setAPIStatus(status) {
+ this.apiStatus = status;
+ this.lastAPICheck = Date.now();
+ }
+
+ /**
+ * Get current uptime in milliseconds
+ */
+ getUptime() {
+ return Date.now() - this.startTime;
+ }
+
+ /**
+ * Get formatted uptime string
+ */
+ getFormattedUptime() {
+ const uptime = this.getUptime();
+ const seconds = Math.floor(uptime / 1000);
+ const minutes = Math.floor(seconds / 60);
+ const hours = Math.floor(minutes / 60);
+ const days = Math.floor(hours / 24);
+
+ if (days > 0) {
+ return `${days}d ${hours % 24}h ${minutes % 60}m`;
+ } else if (hours > 0) {
+ return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+ } else if (minutes > 0) {
+ return `${minutes}m ${seconds % 60}s`;
+ } else {
+ return `${seconds}s`;
+ }
+ }
+
+ /**
+ * Get memory usage stats
+ */
+ getMemoryUsage() {
+ const usage = process.memoryUsage();
+ return {
+ heapUsed: Math.round(usage.heapUsed / 1024 / 1024), // MB
+ heapTotal: Math.round(usage.heapTotal / 1024 / 1024), // MB
+ rss: Math.round(usage.rss / 1024 / 1024), // MB
+ external: Math.round(usage.external / 1024 / 1024), // MB
+ };
+ }
+
+ /**
+ * Get formatted memory usage string
+ */
+ getFormattedMemory() {
+ const mem = this.getMemoryUsage();
+ return `${mem.heapUsed}MB / ${mem.heapTotal}MB (RSS: ${mem.rss}MB)`;
+ }
+
+ /**
+ * Get complete health status
+ */
+ getStatus() {
+ const memory = this.getMemoryUsage();
+
+ return {
+ uptime: this.getUptime(),
+ uptimeFormatted: this.getFormattedUptime(),
+ memory: {
+ heapUsed: memory.heapUsed,
+ heapTotal: memory.heapTotal,
+ rss: memory.rss,
+ external: memory.external,
+ formatted: this.getFormattedMemory(),
+ },
+ api: {
+ status: this.apiStatus,
+ lastCheck: this.lastAPICheck,
+ },
+ lastAIRequest: this.lastAIRequest,
+ timestamp: Date.now(),
+ };
+ }
+
+ /**
+ * Get detailed diagnostics (for admin use)
+ */
+ getDetailedStatus() {
+ const status = this.getStatus();
+ const memory = process.memoryUsage();
+
+ return {
+ ...status,
+ process: {
+ pid: process.pid,
+ platform: process.platform,
+ nodeVersion: process.version,
+ uptime: process.uptime(),
+ },
+ memory: {
+ ...status.memory,
+ arrayBuffers: Math.round(memory.arrayBuffers / 1024 / 1024),
+ },
+ cpu: process.cpuUsage(),
+ };
+ }
+}
+
+export { HealthMonitor };
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| errors.js | +
+
+ |
+ 100% | +45/45 | +97.05% | +66/68 | +100% | +4/4 | +100% | +44/44 | +
| health.js | +
+
+ |
+ 0% | +0/36 | +0% | +0/10 | +9.09% | +1/11 | +0% | +0/36 | +
| permissions.js | +
+
+ |
+ 0% | +0/20 | +0% | +0/23 | +0% | +0/3 | +0% | +0/18 | +
| registerCommands.js | +
+
+ |
+ 0% | +0/17 | +0% | +0/17 | +0% | +0/2 | +0% | +0/17 | +
| retry.js | +
+
+ |
+ 0% | +0/25 | +0% | +0/16 | +0% | +0/6 | +0% | +0/23 | +
| splitMessage.js | +
+
+ |
+ 0% | +0/17 | +0% | +0/13 | +0% | +0/2 | +0% | +0/17 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | /**
+ * Permission checking utilities for Bill Bot
+ *
+ * Provides centralized permission checks for commands and features.
+ */
+
+import { PermissionFlagsBits } from 'discord.js';
+
+/**
+ * Check if a member is an admin
+ *
+ * @param {GuildMember} member - Discord guild member
+ * @param {Object} config - Bot configuration
+ * @returns {boolean} True if member is admin
+ */
+export function isAdmin(member, config) {
+ if (!member || !config) return false;
+
+ // Check if member has Discord Administrator permission
+ if (member.permissions.has(PermissionFlagsBits.Administrator)) {
+ return true;
+ }
+
+ // Check if member has the configured admin role
+ if (config.permissions?.adminRoleId) {
+ return member.roles.cache.has(config.permissions.adminRoleId);
+ }
+
+ return false;
+}
+
+/**
+ * Check if a member has permission to use a command
+ *
+ * @param {GuildMember} member - Discord guild member
+ * @param {string} commandName - Name of the command
+ * @param {Object} config - Bot configuration
+ * @returns {boolean} True if member has permission
+ */
+export function hasPermission(member, commandName, config) {
+ if (!member || !commandName || !config) return false;
+
+ // If permissions are disabled, allow everything
+ if (!config.permissions?.enabled || !config.permissions?.usePermissions) {
+ return true;
+ }
+
+ // Get permission level for this command
+ const permissionLevel = config.permissions?.allowedCommands?.[commandName];
+
+ // If command not in config, default to admin-only for safety
+ if (!permissionLevel) {
+ return isAdmin(member, config);
+ }
+
+ // Check permission level
+ if (permissionLevel === 'everyone') {
+ return true;
+ }
+
+ if (permissionLevel === 'admin') {
+ return isAdmin(member, config);
+ }
+
+ // Unknown permission level - deny for safety
+ return false;
+}
+
+/**
+ * Get a helpful error message for permission denied
+ *
+ * @param {string} commandName - Name of the command
+ * @returns {string} User-friendly error message
+ */
+export function getPermissionError(commandName) {
+ return `❌ You don't have permission to use \`/${commandName}\`.\n\nThis command requires administrator access.`;
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | /**
+ * Command registration utilities for Bill Bot
+ *
+ * Handles registering slash commands with Discord's API
+ */
+
+import { REST, Routes } from 'discord.js';
+import { error as logError, info } from '../logger.js';
+
+/**
+ * Register slash commands with Discord
+ *
+ * @param {Array} commands - Array of command modules with .data property
+ * @param {string} clientId - Discord application/client ID
+ * @param {string} token - Discord bot token
+ * @param {string} [guildId] - Optional guild ID for guild-specific registration (faster for dev)
+ * @returns {Promise<void>}
+ */
+export async function registerCommands(commands, clientId, token, guildId = null) {
+ if (!commands || !Array.isArray(commands)) {
+ throw new Error('Commands must be an array');
+ }
+
+ if (!clientId || !token) {
+ throw new Error('Client ID and token are required');
+ }
+
+ // Convert command modules to JSON for API
+ const commandData = commands.map((cmd) => {
+ if (!cmd.data || typeof cmd.data.toJSON !== 'function') {
+ throw new Error('Each command must have a .data property with toJSON() method');
+ }
+ return cmd.data.toJSON();
+ });
+
+ const rest = new REST({ version: '10' }).setToken(token);
+
+ try {
+ info(`Registering ${commandData.length} slash command(s)`);
+
+ let data;
+ if (guildId) {
+ // Guild-specific commands (instant updates, good for development)
+ data = await rest.put(Routes.applicationGuildCommands(clientId, guildId), {
+ body: commandData,
+ });
+ } else {
+ // Global commands (can take up to 1 hour to update)
+ data = await rest.put(Routes.applicationCommands(clientId), { body: commandData });
+ }
+
+ info(`Successfully registered ${data.length} slash command(s)`, { scope: guildId ? 'guild' : 'global' });
+ } catch (err) {
+ logError('Failed to register commands', { error: err.message });
+ throw err;
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | /**
+ * Retry Utility with Exponential Backoff
+ *
+ * Provides utilities for retrying operations with configurable
+ * exponential backoff and integration with error classification.
+ */
+
+import { debug, error, warn } from '../logger.js';
+import { classifyError, isRetryable } from './errors.js';
+
+/**
+ * Sleep for a specified duration
+ * @param {number} ms - Milliseconds to sleep
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+ return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Calculate delay with exponential backoff
+ * @param {number} attempt - Current attempt number (0-indexed)
+ * @param {number} baseDelay - Base delay in milliseconds
+ * @param {number} maxDelay - Maximum delay in milliseconds
+ * @returns {number} Delay in milliseconds
+ */
+function calculateBackoff(attempt, baseDelay, maxDelay) {
+ // Exponential backoff: baseDelay * 2^attempt
+ const delay = baseDelay * 2 ** attempt;
+
+ // Cap at maxDelay
+ return Math.min(delay, maxDelay);
+}
+
+/**
+ * Retry an async operation with exponential backoff
+ *
+ * @param {Function} fn - Async function to retry
+ * @param {Object} options - Retry configuration options
+ * @param {number} options.maxRetries - Maximum number of retry attempts (default: 3)
+ * @param {number} options.baseDelay - Initial delay in milliseconds (default: 1000)
+ * @param {number} options.maxDelay - Maximum delay in milliseconds (default: 30000)
+ * @param {Function} options.shouldRetry - Custom function to determine if error is retryable
+ * @param {Object} options.context - Optional context for logging
+ * @returns {Promise<any>} Result of the function
+ * @throws {Error} Throws the last error if all retries fail
+ */
+export async function withRetry(fn, options = {}) {
+ const {
+ maxRetries = 3,
+ baseDelay = 1000,
+ maxDelay = 30000,
+ shouldRetry = isRetryable,
+ context = {},
+ } = options;
+
+ let lastError;
+
+ for (let attempt = 0; attempt <= maxRetries; attempt++) {
+ try {
+ // Execute the function
+ return await fn();
+ } catch (err) {
+ lastError = err;
+
+ // Check if we should retry
+ const errorType = classifyError(err, context);
+ const canRetry = shouldRetry(err, context);
+
+ // Log the error
+ if (attempt === 0) {
+ warn(`Operation failed: ${err.message}`, {
+ ...context,
+ errorType,
+ attempt: attempt + 1,
+ maxRetries: maxRetries + 1,
+ });
+ }
+
+ // If this was the last attempt or error is not retryable, throw
+ if (attempt >= maxRetries || !canRetry) {
+ if (!canRetry) {
+ error('Operation failed with non-retryable error', {
+ ...context,
+ errorType,
+ attempt: attempt + 1,
+ error: err.message,
+ });
+ } else {
+ error('Operation failed after all retries', {
+ ...context,
+ errorType,
+ totalAttempts: attempt + 1,
+ error: err.message,
+ });
+ }
+ throw err;
+ }
+
+ // Calculate backoff delay
+ const delay = calculateBackoff(attempt, baseDelay, maxDelay);
+
+ debug(`Retrying in ${delay}ms`, {
+ ...context,
+ attempt: attempt + 1,
+ maxRetries: maxRetries + 1,
+ delay,
+ errorType,
+ });
+
+ // Wait before retrying
+ await sleep(delay);
+ }
+ }
+
+ // Should never reach here, but just in case
+ throw lastError;
+}
+
+/**
+ * Create a retry wrapper with pre-configured options
+ *
+ * @param {Object} defaultOptions - Default retry options
+ * @returns {Function} Configured retry function
+ */
+export function createRetryWrapper(defaultOptions = {}) {
+ return (fn, options = {}) => {
+ return withRetry(fn, { ...defaultOptions, ...options });
+ };
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | /** + * Split Message Utility + * Splits long messages to fit within Discord's 2000-character limit. + */ + +/** + * Discord's maximum message length. + */ +const DISCORD_MAX_LENGTH = 2000; + +/** + * Safe chunk size leaving room for potential overhead. + */ +const SAFE_CHUNK_SIZE = 1990; + +/** + * Splits a message into chunks that fit within Discord's character limit. + * Attempts to split on word boundaries to avoid breaking words, URLs, or emoji. + * + * @param {string} text - The text to split + * @param {number} [maxLength=1990] - Maximum length per chunk (default 1990 to stay under 2000) + * @returns {string[]} Array of text chunks, each within the specified limit + */ +export function splitMessage(text, maxLength = SAFE_CHUNK_SIZE) { + if (!text || text.length <= maxLength) { + return text ? [text] : []; + } + + const chunks = []; + let remaining = text; + + while (remaining.length > 0) { + if (remaining.length <= maxLength) { + chunks.push(remaining); + break; + } + + // Try to find a space to split on (word boundary) + let splitAt = remaining.lastIndexOf(' ', maxLength); + + // If no space found or it's at the start, force split at maxLength + if (splitAt <= 0) { + splitAt = maxLength; + } + + chunks.push(remaining.slice(0, splitAt)); + remaining = remaining.slice(splitAt).trimStart(); + } + + return chunks; +} + +/** + * Checks if a message exceeds Discord's character limit. + * + * @param {string} text - The text to check + * @returns {boolean} True if the message needs splitting + */ +export function needsSplitting(text) { + return text && text.length > DISCORD_MAX_LENGTH; +} + |