fix: Discord message chunking for long queue lists

- Fix chunking logic to properly handle messages over 2000 chars
- Add sendChunkSafe helper to ensure all chunks stay under limit
- Convert Slack emoji codes to Unicode for Discord compatibility
- Reduce maxLength to 1800 for extra Unicode buffer

Fixes issue where 'list' command failed on Discord with 60+ tracks

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: htilly

lib/discord.js

@@ -257,10 +257,62 @@ async function sendDiscordMessage(channelId, text, options = {}) {
             // Convert Slack markdown to Discord markdown
             let discordText = text.replace(/<(https?:\/\/[^|>]+)\|([^>]+)>/g, '[$2]($1)');
 
+            // Convert common Slack emoji codes to Unicode emoji for Discord
+            const emojiMap = {
+                ':notes:': '🎵',
+                ':lock:': '🔒',
+                ':star:': '⭐',
+                ':stopwatch:': '⏱️',
+                ':cricket:': '🦗',
+                ':musical_note:': '🎵',
+                ':headphones:': '🎧',
+                ':speaker:': '🔊',
+                ':mute:': '🔇',
+                ':loud_sound:': '🔊',
+                ':sound:': '🔉',
+                ':fire:': '🔥',
+                ':thumbsup:': '👍',
+                ':thumbsdown:': '👎',
+                ':clap:': '👏',
+                ':party_popper:': '🎉',
+                ':tada:': '🎉',
+                ':warning:': '⚠️',
+                ':x:': '❌',
+                ':white_check_mark:': '✅',
+                ':checkmark:': '✅',
+                ':question:': '❓',
+                ':exclamation:': '❗',
+                ':sparkles:': '✨'
+            };
+            for (const [slackEmoji, unicodeEmoji] of Object.entries(emojiMap)) {
+                discordText = discordText.split(slackEmoji).join(unicodeEmoji);
+            }
+            
             // Discord has a 2000 char limit, split into chunks if needed
-            const maxLength = 1900; // Leave some margin
+            // Use 1800 as max to have buffer for edge cases with Unicode
+            const maxLength = 1800;
             let messages = [];
 
+            // Helper function to send a chunk safely (splitting further if needed)
+            const sendChunkSafe = async (chunk) => {
+                if (chunk.length <= maxLength) {
+                    const message = await channel.send(chunk);
+                    messages.push(message);
+                    return;
+                }
+                // Chunk is still too long, split it
+                let remaining = chunk;
+                while (remaining.length > 0) {
+                    const piece = remaining.substring(0, maxLength);
+                    const message = await channel.send(piece);
+                    messages.push(message);
+                    remaining = remaining.substring(maxLength);
+                    if (remaining.length > 0) {
+                        await new Promise(resolve => setTimeout(resolve, 300));
+                    }
+                }
+            };
+            
             if (discordText.length <= maxLength) {
                 // Single message
                 const message = await channel.send(discordText);
@@ -274,44 +326,33 @@ async function sendDiscordMessage(channelId, text, options = {}) {
 
                 for (let i = 0; i < lines.length; i++) {
                     const line = lines[i];
+                    const potentialLength = currentChunk.length + line.length + 1; // +1 for newline
 
-                    if ((currentChunk + line + '\n').length > maxLength) {
-                        // Send current chunk
+                    if (potentialLength > maxLength) {
+                        // Send current chunk if it has content
                         if (currentChunk.trim().length > 0) {
-                            const message = await channel.send(currentChunk);
-                            messages.push(message);
+                            await sendChunkSafe(currentChunk);
                             chunkCount++;
                             currentChunk = '';
                             // Small delay between messages
-                            await new Promise(resolve => setTimeout(resolve, 500));
+                            await new Promise(resolve => setTimeout(resolve, 300));
                         }
 
-                        // Handle oversized single lines by splitting them
+                        // Handle oversized single lines
                         if (line.length > maxLength) {
-                            // Split the line into smaller chunks
-                            let remainingLine = line;
-                            while (remainingLine.length > 0) {
-                                const chunk = remainingLine.substring(0, maxLength);
-                                const message = await channel.send(chunk);
-                                messages.push(message);
-                                chunkCount++;
-                                remainingLine = remainingLine.substring(maxLength);
-                                if (remainingLine.length > 0) {
-                                    await new Promise(resolve => setTimeout(resolve, 500));
-                                }
-                            }
-                            // Skip adding to currentChunk since we already sent it
+                            await sendChunkSafe(line);
+                            chunkCount++;
+                            await new Promise(resolve => setTimeout(resolve, 300));
                             continue;
                         }
                     }
 
                     currentChunk += line + '\n';
                 }
 
-                // Send remaining chunk
+                // Send remaining chunk (with safety check)
                 if (currentChunk.trim().length > 0) {
-                    const message = await channel.send(currentChunk);
-                    messages.push(message);
+                    await sendChunkSafe(currentChunk);
                     chunkCount++;
                 }