add permission checks and error logging

Author: sneak-it

index.js

@@ -154,6 +154,101 @@ function checkRateLimit(userId, action, limit) {
     return { allowed: true, retryAfter: 0 };
 }
 
+/**
+ * Required permissions for bot operations
+ */
+const REQUIRED_PERMISSIONS = {
+    SEND_MESSAGES: "SendMessages",
+    EMBED_LINKS: "EmbedLinks",
+    READ_MESSAGE_HISTORY: "ReadMessageHistory",
+    VIEW_CHANNEL: "ViewChannel"
+};
+
+/**
+ * Check if bot has required permissions in a channel
+ * @param {import('discord.js').GuildChannel} channel - The channel to check
+ * @param {string[]} requiredPermissions - Array of permission names to check
+ * @returns {Object} - { hasPermissions: boolean, missing: string[] }
+ */
+function checkChannelPermissions(channel, requiredPermissions = []) {
+    if (!channel) {
+        return { hasPermissions: false, missing: ["Channel not found"] };
+    }
+    
+    // Check if channel is a text-based channel
+    if (!channel.isTextBased?.()) {
+        return { hasPermissions: false, missing: ["Channel is not text-based"] };
+    }
+    
+    const missing = [];
+    const botMember = channel.guild?.members?.me;
+    
+    if (!botMember) {
+        return { hasPermissions: false, missing: ["Bot member not found in guild"] };
+    }
+    
+    const permissions = channel.permissionsFor(botMember);
+    if (!permissions) {
+        return { hasPermissions: false, missing: ["Could not resolve permissions"] };
+    }
+    
+    // Check each required permission
+    for (const perm of requiredPermissions) {
+        if (!permissions.has(perm)) {
+            missing.push(perm);
+        }
+    }
+    
+    return {
+        hasPermissions: missing.length === 0,
+        missing
+    };
+}
+
+/**
+ * Validate bot can send messages to a channel
+ * @param {import('discord.js').GuildChannel} channel - The channel to validate
+ * @returns {Object} - { valid: boolean, error?: string }
+ */
+function validateChannelForSend(channel) {
+    const result = checkChannelPermissions(channel, [
+        REQUIRED_PERMISSIONS.VIEW_CHANNEL,
+        REQUIRED_PERMISSIONS.SEND_MESSAGES,
+        REQUIRED_PERMISSIONS.EMBED_LINKS
+    ]);
+    
+    if (!result.hasPermissions) {
+        return {
+            valid: false,
+            error: `Missing permissions: ${result.missing.join(", ")}`
+        };
+    }
+    
+    return { valid: true };
+}
+
+/**
+ * Validate bot can edit messages in a channel
+ * @param {import('discord.js').GuildChannel} channel - The channel to validate
+ * @returns {Object} - { valid: boolean, error?: string }
+ */
+function validateChannelForEdit(channel) {
+    const result = checkChannelPermissions(channel, [
+        REQUIRED_PERMISSIONS.VIEW_CHANNEL,
+        REQUIRED_PERMISSIONS.READ_MESSAGE_HISTORY,
+        REQUIRED_PERMISSIONS.EMBED_LINKS
+    ]);
+    
+    if (!result.hasPermissions) {
+        return {
+            valid: false,
+            error: `Missing permissions: ${result.missing.join(", ")}`
+        };
+    }
+    
+    return { valid: true };
+}
+
 /**
  * Validate IPv4 address format
  * @param {string} ip - The IP address to validate
@@ -736,6 +831,13 @@ bot.on("ready", async () => {
         logChannel = guild.channels.cache.get(config.logging.channelID);
         if (!logChannel) {
             console.warn(`Log channel ${config.logging.channelID} not found in guild ${config.logging.guildID}`);
+        } else {
+            // Validate bot has required permissions in log channel
+            const permCheck = validateChannelForSend(logChannel);
+            if (!permCheck.valid) {
+                console.warn(`Log channel ${config.logging.channelID} permission issue: ${permCheck.error}`);
+                logChannel = null; // Disable logging if permissions are missing
+            }
         }
     } else {
         console.warn(`Guild ${config.logging.guildID} not found`);
@@ -826,6 +928,13 @@ async function intervalFunction() {
             try {
                 await withRetry(async () => {
                     const channel = await bot.channels.fetch(e.channelID);
+                    
+                    // Validate permissions before editing
+                    const permCheck = validateChannelForEdit(channel);
+                    if (!permCheck.valid) {
+                        throw new Error(`Permission check failed for channel ${e.channelID}: ${permCheck.error}`);
+                    }
+                    
                     const message = await channel.messages.fetch(e.messageID);
                     await message.edit({ content: "‎", embeds: [embed] });
                 });
@@ -1477,6 +1586,11 @@ const notifyUsers = async (map, serverObj) => {
                         if (!channel) {
                             throw new Error(`Fallback channel ${config.fallback.channelID} not found`);
                         }
+                        // Validate permissions before sending
+                        const permCheck = validateChannelForSend(channel);
+                        if (!permCheck.valid) {
+                            throw new Error(`Fallback channel permission error: ${permCheck.error}`);
+                        }
                         channel.send({
                             embeds: [backupEmbed],
                             content: fallbackContent
@@ -1563,13 +1677,23 @@ const notifyUsers = async (map, serverObj) => {
 
             try {
                 await withRetry(async () => {
-                    bot.guilds.cache
-                        .get(config.fallback.guildID)
-                        .channels.cache.get(config.fallback.channelID)
-                        .send({
-                            embeds: [backupEmbed],
-                            content: fallbackContent
-                        });
+                    const guild = bot.guilds.cache.get(config.fallback.guildID);
+                    if (!guild) {
+                        throw new Error(`Fallback guild ${config.fallback.guildID} not found`);
+                    }
+                    const channel = guild.channels.cache.get(config.fallback.channelID);
+                    if (!channel) {
+                        throw new Error(`Fallback channel ${config.fallback.channelID} not found`);
+                    }
+                    // Validate permissions before sending
+                    const permCheck = validateChannelForSend(channel);
+                    if (!permCheck.valid) {
+                        throw new Error(`Fallback channel permission error: ${permCheck.error}`);
+                    }
+                    channel.send({
+                        embeds: [backupEmbed],
+                        content: fallbackContent
+                    });
                 });
             } catch (fallbackError) {
                 console.error(`Failed to send fallback notification for ${map}:`, fallbackError);