fix: address all CodeRabbit + Bugbot review comments

src/db.js:
- Add pool.on('error') handler to prevent unhandled errors crashing process
- Make SSL configurable via DB_SSL_REJECT_UNAUTHORIZED env var
  (defaults to rejectUnauthorized:true instead of insecure false)
- Add re-entrancy guard to initDb to prevent double initialization
- Clean up pool on init failure so getPool() doesn't return broken instance
- Wrap closeDb in try/catch so shutdown errors don't crash

src/modules/config.js:
- Remove process.exit from loadConfigFromFile — always throw instead
  (no runtime code path should hard-exit the process)
- Remove unused getConfigSection export (dead code)
- Remove unused sectionConfig variable (dead store in setConfigValue)
- Fix cache-before-DB-write: write to database first, then update cache
- Fix concurrent section writes: use transaction with FOR UPDATE row lock
- Fix deep nested paths: read-modify-write in JS instead of jsonb_set
  (jsonb_set silently drops updates when intermediate keys don't exist)
- Fix parseValue: preserve large numeric strings beyond MAX_SAFE_INTEGER
- Wrap DB seeding in transaction to prevent partial config loss on restart

src/commands/config.js:
- Fix collectConfigPaths to emit leaf-only entries (was emitting branches too)
- Derive valid sections from live config instead of hardcoded VALID_SECTIONS
- Fix 'New Value' display: traverse full dot-path instead of only first key
  (path.split('.').slice(1)[0] broke for paths deeper than section.key)
- Add embed 6000-char limit guard with truncation notice
- Switch section options to autocomplete (derived from live config)

src/index.js:
- Wrap closeDb in try/catch in gracefulShutdown

README.md:
- Change json code block to jsonc (has // comments)

Author: BillChirico

README.md

@@ -51,7 +51,7 @@ AI-powered Discord bot for the Volvox community.
 
 ## Config
 
-```json
+```jsonc
 {
   "ai": {
     "enabled": true,

src/commands/config.js

@@ -6,8 +6,6 @@
 import { SlashCommandBuilder, EmbedBuilder } from 'discord.js';
 import { getConfig, setConfigValue, resetConfig } from '../modules/config.js';
 
-const VALID_SECTIONS = ['ai', 'chimeIn', 'welcome', 'moderation', 'logging', 'permissions'];
-
 export const data = new SlashCommandBuilder()
   .setName('config')
   .setDescription('View or manage bot configuration (Admin only)')
@@ -20,14 +18,7 @@ export const data = new SlashCommandBuilder()
           .setName('section')
           .setDescription('Specific config section to view')
           .setRequired(false)
-          .addChoices(
-            { name: 'AI Settings', value: 'ai' },
-            { name: 'Chime In', value: 'chimeIn' },
-            { name: 'Welcome Messages', value: 'welcome' },
-            { name: 'Moderation', value: 'moderation' },
-            { name: 'Logging', value: 'logging' },
-            { name: 'Permissions', value: 'permissions' }
-          )
+          .setAutocomplete(true)
       )
   )
   .addSubcommand(subcommand =>
@@ -57,38 +48,30 @@ export const data = new SlashCommandBuilder()
           .setName('section')
           .setDescription('Section to reset (omit to reset all)')
           .setRequired(false)
-          .addChoices(
-            { name: 'AI Settings', value: 'ai' },
-            { name: 'Chime In', value: 'chimeIn' },
-            { name: 'Welcome Messages', value: 'welcome' },
-            { name: 'Moderation', value: 'moderation' },
-            { name: 'Logging', value: 'logging' },
-            { name: 'Permissions', value: 'permissions' }
-          )
+          .setAutocomplete(true)
       )
   );
 
 export const adminOnly = true;
 
 /**
- * Recursively collect dot-notation paths for a config object.
- * Includes object paths, leaf paths, and nested array/object paths.
+ * 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
+ * @returns {string[]} Dot-notation config paths (leaf-only)
  */
 function collectConfigPaths(source, prefix = '', paths = []) {
   if (Array.isArray(source)) {
     source.forEach((value, index) => {
       const path = prefix ? `${prefix}.${index}` : String(index);
-      paths.push(path);
-
       if (value && typeof value === 'object') {
         collectConfigPaths(value, path, paths);
+      } else {
+        paths.push(path);
       }
     });
-
     return paths;
   }
 
@@ -98,45 +81,52 @@ function collectConfigPaths(source, prefix = '', paths = []) {
 
   for (const [key, value] of Object.entries(source)) {
     const path = prefix ? `${prefix}.${key}` : key;
-    paths.push(path);
-
     if (value && typeof value === 'object') {
       collectConfigPaths(value, path, paths);
+    } else {
+      paths.push(path);
     }
   }
 
   return paths;
 }
 
 /**
- * Handle autocomplete for config paths
+ * Handle autocomplete for config paths and section names
  * @param {Object} interaction - Discord interaction
  */
 export async function autocomplete(interaction) {
-  const focusedValue = interaction.options.getFocused().toLowerCase().trim();
+  const focusedOption = interaction.options.getFocused(true);
+  const focusedValue = focusedOption.value.toLowerCase().trim();
   const config = getConfig();
 
-  const paths = collectConfigPaths(config);
-
-  const filtered = 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);
+  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(
-    filtered.map(p => ({ name: p, value: p }))
-  );
+  await interaction.respond(choices);
 }
 
 /**
@@ -159,6 +149,9 @@ export async function execute(interaction) {
   }
 }
 
+/** @type {number} Discord embed total character limit */
+const EMBED_CHAR_LIMIT = 6000;
+
 /**
  * Handle /config view
  */
@@ -183,25 +176,46 @@ async function handleView(interaction) {
       }
 
       embed.setDescription(`**${section.toUpperCase()} Configuration**`);
+      const sectionJson = JSON.stringify(sectionData, null, 2);
       embed.addFields({
         name: 'Settings',
-        value: '```json\n' + JSON.stringify(sectionData, null, 2) + '\n```'
+        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 + embed.data.description.length;
+      let truncated = false;
+
       for (const [key, value] of Object.entries(config)) {
         const jsonStr = JSON.stringify(value, null, 2);
-        const truncated = jsonStr.length > 1000
-          ? jsonStr.slice(0, 997) + '...'
-          : jsonStr;
-
+        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: `${key.toUpperCase()}`,
-          value: '```json\n' + truncated + '\n```',
+          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 });
@@ -220,11 +234,12 @@ async function handleSet(interaction) {
   const path = interaction.options.getString('path');
   const value = interaction.options.getString('value');
 
-  // Validate section exists
+  // Validate section exists in live config
   const section = path.split('.')[0];
-  if (!VALID_SECTIONS.includes(section)) {
+  const validSections = Object.keys(getConfig());
+  if (!validSections.includes(section)) {
     return await interaction.reply({
-      content: `❌ Invalid section '${section}'. Valid sections: ${VALID_SECTIONS.join(', ')}`,
+      content: `❌ Invalid section '${section}'. Valid sections: ${validSections.join(', ')}`,
       ephemeral: true
     });
   }
@@ -234,12 +249,15 @@ async function handleSet(interaction) {
 
     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 embed = new EmbedBuilder()
       .setColor(0x57F287)
       .setTitle('✅ Config Updated')
       .addFields(
         { name: 'Path', value: `\`${path}\``, inline: true },
-        { name: 'New Value', value: `\`${JSON.stringify(updatedSection[path.split('.').slice(1)[0]], null, 2) ?? value}\``, inline: true }
+        { name: 'New Value', value: `\`${JSON.stringify(leafValue, null, 2) ?? value}\``, inline: true }
       )
       .setFooter({ text: 'Changes take effect immediately' })
       .setTimestamp();

src/db.js

@@ -11,45 +11,75 @@ const { Pool } = pg;
 /** @type {pg.Pool | null} */
 let pool = null;
 
+/** @type {boolean} Re-entrancy guard for initDb */
+let initializing = false;
+
 /**
  * Initialize the database connection pool and create schema
  * @returns {Promise<pg.Pool>} The connection pool
  */
 export async function initDb() {
-  const connectionString = process.env.DATABASE_URL;
-  if (!connectionString) {
-    throw new Error('DATABASE_URL environment variable is not set');
+  if (pool) return pool;
+  if (initializing) {
+    throw new Error('initDb is already in progress');
   }
 
-  pool = new Pool({
-    connectionString,
-    max: 5,
-    idleTimeoutMillis: 30000,
-    connectionTimeoutMillis: 10000,
-    // Railway internal connections don't need SSL
-    ssl: connectionString.includes('railway.internal') ? false : { rejectUnauthorized: false },
-  });
-
-  // Test connection
-  const client = await pool.connect();
+  initializing = true;
   try {
-    await client.query('SELECT NOW()');
-    info('Database connected');
-  } finally {
-    client.release();
-  }
+    const connectionString = process.env.DATABASE_URL;
+    if (!connectionString) {
+      throw new Error('DATABASE_URL environment variable is not set');
+    }
 
-  // Create schema
-  await pool.query(`
-    CREATE TABLE IF NOT EXISTS config (
-      key TEXT PRIMARY KEY,
-      value JSONB NOT NULL,
-      updated_at TIMESTAMPTZ DEFAULT NOW()
-    )
-  `);
+    pool = new Pool({
+      connectionString,
+      max: 5,
+      idleTimeoutMillis: 30000,
+      connectionTimeoutMillis: 10000,
+      // Railway internal connections don't need SSL; others default to verified TLS
+      ssl: connectionString.includes('railway.internal')
+        ? false
+        : process.env.DB_SSL_REJECT_UNAUTHORIZED === 'false'
+          ? { rejectUnauthorized: false }
+          : { rejectUnauthorized: true },
+    });
 
-  info('Database schema initialized');
-  return pool;
+    // 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;
+  }
 }
 
 /**
@@ -69,8 +99,13 @@ export function getPool() {
  */
 export async function closeDb() {
   if (pool) {
-    await pool.end();
-    pool = null;
-    info('Database pool closed');
+    try {
+      await pool.end();
+      info('Database pool closed');
+    } catch (err) {
+      logError('Error closing database pool', { error: err.message });
+    } finally {
+      pool = null;
+    }
   }
 }

src/index.js

@@ -249,7 +249,11 @@ async function gracefulShutdown(signal) {
 
   // 3. Close database pool
   info('Closing database connection');
-  await closeDb();
+  try {
+    await closeDb();
+  } catch (err) {
+    error('Failed to close database pool', { error: err.message });
+  }
 
   // 4. Destroy Discord client
   info('Disconnecting from Discord');