vantiv.io 1.0.9 → 1.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vantiv.io",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Enterprise WebSocket infrastructure for Highrise featuring spatial intelligence systems, memory-optimized architecture, and production-grade reliability for scalable application development",
   "keywords": [
     "highrise",

package/src/classes/Actions/Music.js

@@ -1,9 +1,9 @@
 const { IcecastStreamer, IcecastQueue, Track, YouTubeExtractor, IcecastServer } = require('./lib/AudioStreaming.js');
-const EventEmitter = require('events')
+const EventEmitter = require('events');
 
 class MusicClass extends EventEmitter {
     constructor(bot, config = {}) {
-        super()
+        super();
         this.bot = bot;
         this.config = {
             enabled: config.enabled || false,
@@ -25,9 +25,8 @@ class MusicClass extends EventEmitter {
         this.setupEventHandlers();
 
         if (this.config.autoStartServer) {
-            this.startWebServer();
+            this._startWebServer();
         }
-
     }
 
     initializeStreamer() {
@@ -36,25 +35,24 @@ class MusicClass extends EventEmitter {
             this.queue = new IcecastQueue(this.streamer, { ...this.config.queue, ...this.config.icecast });
 
             this.streamer.on('playbackStart', (track) => {
-                this.emit('playbackStart', track);
+                this.emit('MusicStart', track);
             });
 
             this.streamer.on('playbackEnd', (track) => {
-                this.emit('playbackEnd', track);
+                this.emit('MusicEnd', track);
             });
 
             this.streamer.on('progress', (data) => {
-                this.emit('progress', data);
+                this.emit('Progress', data);
             });
 
             this.streamer.on('error', (error) => {
-                this.emit('error', error);
+                this.emit('Error', error);
             });
 
             this.streamer.on('streamStopped', () => {
-                this.emit('streamStopped');
+                this.emit('StreamEnded');
             });
-
         } catch (error) {
             console.error('Failed to initialize Icecast streamer:', error);
             throw error;
@@ -71,86 +69,57 @@ class MusicClass extends EventEmitter {
         });
     }
 
-    async play(query, metadata = {}) {
+    async play(input, metadata = {}) {
         try {
             if (!this.streamer) {
                 throw new Error('Streamer not initialized');
             }
 
-            let trackInfo;
-            let source = 'direct';
-
-            if (this.isValidUrl(query)) {
-                if (query.includes('youtube.com') || query.includes('youtu.be')) {
-                    try {
-                        trackInfo = await YouTubeExtractor.getStreamUrl(query);
-                    } catch (error) {
-                        return {
-                            success: false,
-                            error: error.message.includes('yt-dlp')
-                                ? 'Missing dependency: yt-dlp'
-                                : `YouTube error: ${error.message}`
-                        };
-                    }
-                    source = 'youtube';
-                } else {
-                    trackInfo = {
-                        url: query,
-                        title: metadata.title || 'Unknown Track',
-                        duration: metadata.duration || 0,
-                        thumbnail: metadata.thumbnail || null
-                    };
+            let result;
+            if (this.isValidUrl(input)) {
+                if (input.includes('youtube.com') || input.includes('youtu.be')) {
+                    result = await this.queue.addFromYouTube(input, metadata);
                 }
             } else {
-                trackInfo = await YouTubeExtractor.searchTrack(query);
-                source = 'youtube';
+                result = await this.queue.addFromYouTube(input, metadata);
             }
 
-            if (!trackInfo) {
+            if (!result.added) {
                 return {
                     success: false,
-                    error: 'Could not find or play the requested track'
+                    error: result.reason === 'duplicate' ? 'Track already in queue' : 'Failed to add track'
                 };
             }
 
-            const track = new Track({
-                url: trackInfo.url,
-                title: trackInfo.title || metadata.title || 'Unknown Track',
-                duration: trackInfo.duration || metadata.duration || 0,
-                requester: metadata.requester || 'System',
-                requesterId: metadata.requesterId || 'system',
-                thumbnail: trackInfo.thumbnail || metadata.thumbnail,
-                source: source
-            });
-
-            const result = await this.queue.add(track);
+            const track = this.queue.getQueue()[result.position - 1] || 
+                         (result.isNowPlaying ? this.streamer.currentTrack : null);
 
             return {
                 success: true,
-                track: {
+                track: track ? {
                     title: track.title,
                     duration: track.duration,
                     formattedDuration: track.getFormattedDuration(),
                     requester: track.requester,
                     thumbnail: track.thumbnail
-                },
+                } : null,
                 position: result.position,
                 isNowPlaying: result.isNowPlaying || false
             };
-
         } catch (error) {
             console.error('Error playing track:', error);
             return {
                 success: false,
-                error: error.message
+                error: error.message.includes('yt-dlp')
+                    ? 'Missing dependency: yt-dlp or FFmpeg'
+                    : error.message
             };
         }
     }
 
     async skip() {
         try {
-            const result = await this.queue.skip();
-
+            const success = await this.queue.skip();
             let upcoming = null;
             if (this.queue.queue.length > 0) {
                 const nextTrack = this.queue.queue[0];
@@ -160,25 +129,16 @@ class MusicClass extends EventEmitter {
                     formattedDuration: nextTrack.getFormattedDuration()
                 };
             }
-
-            return {
-                success: result,
-                upcoming: upcoming
-            };
+            return { success, upcoming };
         } catch (error) {
             console.error('Error skipping track:', error);
-            return {
-                success: false,
-                error: error.message
-            };
+            return { success: false, error: error.message };
         }
     }
 
     getNowPlaying() {
         const np = this.streamer.getNowPlaying();
-        if (!np || !np.track) {
-            return null;
-        }
+        if (!np || !np.track) return null;
 
         return {
             track: np.track,
@@ -193,11 +153,12 @@ class MusicClass extends EventEmitter {
     }
 
     getQueue() {
+        const queue = this.queue?.getQueue() || [];
         return {
-            queue: this.queue?.getQueue(),
-            upcoming: this.queue?.getQueue().slice(0, 10),
-            loopMode: this.queue.loopMode,
-            length: this.queue.queue.length
+            queue,
+            upcoming: queue.slice(0, 10),
+            loopMode: this.queue?.loopMode || 'off',
+            length: queue.length
         };
     }
 
@@ -206,30 +167,18 @@ class MusicClass extends EventEmitter {
         const currentIndex = modes.indexOf(this.queue.loopMode);
         const nextIndex = (currentIndex + 1) % modes.length;
         this.queue.loopMode = modes[nextIndex];
-
-        return {
-            success: true,
-            newMode: this.queue.loopMode
-        };
+        return { success: true, newMode: this.queue.loopMode };
     }
 
     shuffle() {
-        if (this.queue.queue.length === 0) {
-            return {
-                success: false,
-                error: 'Queue is empty'
-            };
+        if (!this.queue || this.queue.queue.length === 0) {
+            return { success: false, error: 'Queue is empty' };
         }
-
         for (let i = this.queue.queue.length - 1; i > 0; i--) {
             const j = Math.floor(Math.random() * (i + 1));
             [this.queue.queue[i], this.queue.queue[j]] = [this.queue.queue[j], this.queue.queue[i]];
         }
-
-        return {
-            success: true,
-            queue: this.getQueue()
-        };
+        return { success: true, queue: this.getQueue() };
     }
 
     removeFromQueue(index) {
@@ -255,11 +204,9 @@ class MusicClass extends EventEmitter {
 
     formatDuration(seconds) {
         if (!seconds) return '0:00';
-
         const hours = Math.floor(seconds / 3600);
         const minutes = Math.floor((seconds % 3600) / 60);
         const secondsRemaining = Math.floor(seconds % 60);
-
         if (hours > 0) {
             return `${hours}:${minutes.toString().padStart(2, '0')}:${secondsRemaining.toString().padStart(2, '0')}`;
         }
@@ -275,12 +222,26 @@ class MusicClass extends EventEmitter {
         };
     }
 
+    _startWebServer() {
+        try {
+            this.webServer = new IcecastServer({
+                port: this.config.serverPort,
+                publicStreamUrl: this.streamer.publicStreamUrl,
+                logger: this.bot.utils?.logger || console
+            });
+            this.webServer.start();
+            return true;
+        } catch (error) {
+            console.error('Failed to start web server:', error);
+            return false;
+        }
+    }
+
     destroy() {
         try {
             if (this.streamer) {
                 this.streamer.stop();
             }
-
             return true;
         } catch (error) {
             console.error('Error destroying music class:', error);

package/src/classes/Actions/lib/AudioStreaming.js

@@ -1,6 +1,9 @@
 const express = require('express');
 const { spawn } = require('child_process');
 const EventEmitter = require('events');
+const fs = require('fs').promises;
+const os = require('os');
+const path = require('path');
 
 class IcecastStreamer extends EventEmitter {
     constructor(config = {}) {
@@ -12,25 +15,30 @@ class IcecastStreamer extends EventEmitter {
             sourcePassword: config.sourcePassword || 'hackme',
             fallbackUrl: config.fallbackUrl || '',
             fallbackEnabled: config.fallbackEnabled || false,
-            audioFormat: config.audioFormat || 'mp3',
-            audioBitrate: config.audioBitrate || '192k',
+            audioFormat: config.audioFormat || 'webm',
+            audioBitrate: config.audioBitrate || '128k',
             audioSampleRate: config.audioSampleRate || 48000,
             audioChannels: config.audioChannels || 2,
-            contentType: config.contentType || 'audio/mpeg'
+            contentType: config.contentType || 'audio/webm'
         };
 
         this.ffmpegProcess = null;
         this.fallbackProcess = null;
-        this.isStreaming = false; // Only for actual music
-        this.isFallbackActive = false; // Separate flag for fallback
+        this.isStreaming = false;
+        this.isFallbackActive = false;
+        this.songEmitted = false;
+        this.fallbackEmitted = false;
         this.currentTrack = null;
+        this.tempFilesToDelete = new Set();
 
         this.icecastUrl = `icecast://source:${this.config.sourcePassword}@${this.config.server}:${this.config.port}${this.config.mount}`;
         this.publicStreamUrl = `http://${this.config.server}:${this.config.port}${this.config.mount}`;
     }
 
     getFFmpegArgs(url) {
-        return [
+        const args = [];
+
+        args.push(
             '-re',
             '-i', url,
             '-f', this.config.audioFormat,
@@ -40,12 +48,18 @@ class IcecastStreamer extends EventEmitter {
             '-ac', this.config.audioChannels.toString(),
             '-b:a', this.config.audioBitrate,
             this.icecastUrl
-        ];
+        );
+
+        return args;
     }
 
     getFallbackFFmpegArgs() {
         return [
             '-re',
+            '-reconnect', '1',
+            '-reconnect_at_eof', '1',
+            '-reconnect_streamed', '1',
+            '-reconnect_delay_max', '5',
             '-i', this.config.fallbackUrl,
             '-f', this.config.audioFormat,
             '-content_type', this.config.contentType,
@@ -77,9 +91,14 @@ class IcecastStreamer extends EventEmitter {
                 requesterId: metadata.requesterId || 'system',
                 thumbnail: metadata.thumbnail,
                 source: metadata.source || 'stream',
-                startedAt: Date.now()
+                startedAt: Date.now(),
+                isTempFile: metadata.isTempFile || false
             });
 
+            if (metadata.isTempFile) {
+                this.tempFilesToDelete.add(url);
+            }
+
             this.isStreaming = true;
             this.isFallbackActive = false;
 
@@ -107,12 +126,13 @@ class IcecastStreamer extends EventEmitter {
                     this.emit('progress', {
                         position: this.currentTrack.position,
                         duration: this.currentTrack.duration,
-                        progress: this.currentTrack.duration > 0 ?
+                        percentage: this.currentTrack.duration > 0 ?
                             (this.currentTrack.position / this.currentTrack.duration) * 100 : 0
                     });
                 }
 
-                if (message.includes('Stream mapping') || message.includes('Output')) {
+                if (!this.songEmitted && (message.includes('Stream mapping') || message.includes('Output'))) {
+                    this.songEmitted = true;
                     this.emit('playbackStart', this.currentTrack);
                     resolve();
                 }
@@ -123,21 +143,38 @@ class IcecastStreamer extends EventEmitter {
                 }
             });
 
-            this.ffmpegProcess.on('close', (code) => {
+            this.ffmpegProcess.on('close', async (code) => {
                 const endedTrack = this.currentTrack;
 
                 this.isStreaming = false;
                 this.currentTrack = null;
                 this.ffmpegProcess = null;
+                this.songEmitted = false;
+
+                if (endedTrack?.url && this.tempFilesToDelete.has(endedTrack.url)) {
+                    try {
+                        await fs.unlink(endedTrack.url);
+                        this.tempFilesToDelete.delete(endedTrack.url);
+                    } catch { }
+                }
 
                 this.emit('playbackEnd', endedTrack);
                 this.emit('streamEnd', { code, track: endedTrack });
             });
 
-            this.ffmpegProcess.on('error', (err) => {
+            this.ffmpegProcess.on('error', async (err) => {
                 console.error('FFmpeg process error:', err);
                 this.isStreaming = false;
                 this.currentTrack = null;
+                this.songEmitted = false;
+
+                if (this.currentTrack?.url && this.tempFilesToDelete.has(this.currentTrack.url)) {
+                    try {
+                        await fs.unlink(this.currentTrack.url);
+                        this.tempFilesToDelete.delete(this.currentTrack.url);
+                    } catch { }
+                }
+
                 reject(err);
                 this.emit('error', err);
             });
@@ -174,7 +211,8 @@ class IcecastStreamer extends EventEmitter {
         this.fallbackProcess.stderr.on('data', (data) => {
             const message = data.toString();
 
-            if (message.includes('Stream mapping') || message.includes('Output')) {
+            if (!this.fallbackEmitted && (message.includes('Stream mapping') || message.includes('Output'))) {
+                this.fallbackEmitted = true;
                 this.emit('fallbackStart', this.currentTrack);
             }
 
@@ -187,13 +225,14 @@ class IcecastStreamer extends EventEmitter {
             this.isFallbackActive = false;
             this.currentTrack = null;
             this.fallbackProcess = null;
-
+            this.fallbackEmitted = false;
             this.emit('fallbackEnd', { code });
         });
 
         this.fallbackProcess.on('error', (err) => {
             console.error('Fallback FFmpeg process error:', err);
             this.isFallbackActive = false;
+            this.fallbackEmitted = false;
             this.currentTrack = null;
         });
 
@@ -206,6 +245,7 @@ class IcecastStreamer extends EventEmitter {
             this.fallbackProcess = null;
             this.isFallbackActive = false;
             this.currentTrack = null;
+            this.fallbackEmitted = false;
             this.emit('fallbackStopped');
             return true;
         }
@@ -217,6 +257,7 @@ class IcecastStreamer extends EventEmitter {
             this.ffmpegProcess.kill('SIGKILL');
             this.ffmpegProcess = null;
             this.isStreaming = false;
+            this.songEmitted = false;
             this.emit('streamStopped');
         }
 
@@ -286,15 +327,14 @@ class Track {
         this.thumbnail = data.thumbnail;
         this.source = data.source;
         this.isFallback = data.isFallback || false;
+        this.isTempFile = data.isTempFile || false;
     }
 
     getFormattedDuration() {
         if (!this.duration) return 'Unknown';
-
         const hours = Math.floor(this.duration / 3600);
         const minutes = Math.floor((this.duration % 3600) / 60);
         const seconds = Math.floor(this.duration % 60);
-
         if (hours > 0) {
             return `${hours}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
         }
@@ -312,12 +352,9 @@ class IcecastQueue {
         this.history = [];
         this.maxHistory = config.maxHistory || 50;
         this.skipRequested = false;
-
         this.fallbackEnabled = config.fallbackEnabled || false;
         this.fallbackUrl = config.fallbackUrl || '';
-
         this.setupEventListeners();
-
         this.checkAndStartFallback();
     }
 
@@ -326,18 +363,15 @@ class IcecastQueue {
             if (track && !track.isFallback) {
                 this.addToHistory(track, true);
             }
-
             if (this.skipRequested) {
                 this.skipRequested = false;
                 return;
             }
-
             if (this.loopMode === 'track' && track && !track.isFallback) {
                 this.queue.unshift(new Track({ ...track }));
             } else if (this.loopMode === 'queue' && track && !track.isFallback) {
                 this.queue.push(new Track({ ...track }));
             }
-
             setTimeout(() => this.playNext(), 300);
         });
 
@@ -361,7 +395,6 @@ class IcecastQueue {
             !this.streamer.isFallbackActive &&
             this.fallbackEnabled &&
             this.fallbackUrl) {
-
             setTimeout(() => {
                 if (this.queue.length === 0 &&
                     !this.streamer.isStreaming &&
@@ -377,15 +410,12 @@ class IcecastQueue {
         if (!isNewTrack) {
             return { position: -1, added: false, reason: 'duplicate' };
         }
-
         this.queue.push(track);
         const position = this.queue.length;
-
         if (!this.streamer.isStreaming && this.queue.length === 1) {
             await this.playNext();
             return { position: 1, added: true, isNowPlaying: true };
         }
-
         return { position, added: true, isNowPlaying: false };
     }
 
@@ -393,46 +423,51 @@ class IcecastQueue {
         if (this.currentTrack && !this.currentTrack.isFallback) {
             this.queue.unshift(new Track({ ...this.currentTrack }));
         }
-
         this.queue.unshift(track);
         await this.skip();
         return { position: 1, added: true, isNowPlaying: true };
     }
 
-    async playNext() {
-        if (this.isProcessing) {
-            return false;
+    async addFromYouTube(input, metadata) {
+        let trackData;
+        if (input.startsWith('http')) {
+            trackData = await YouTubeExtractor.downloadAudioToTempFile(input);
+        } else {
+            trackData = await YouTubeExtractor.searchAndDownload(input);
         }
+        trackData.requester = metadata.requester
+        trackData.requesterId = metadata.requesterId
 
-        this.isProcessing = true;
+        const track = new Track(trackData);
+        return await this.add(track);
+    }
 
+    async playNext() {
+        if (this.isProcessing) return false;
+        this.isProcessing = true;
         try {
             if (this.streamer.isFallbackActive) {
                 this.streamer.stopFallback();
                 await this.delay(200);
             }
-
             if (this.queue.length === 0) {
                 this.checkAndStartFallback();
                 return false;
             }
-
             const nextTrack = this.queue.shift();
-
             if (!nextTrack?.url) {
                 setTimeout(() => this.playNext(), 1000);
                 return false;
             }
-
             await this.streamer.streamToIcecast(nextTrack.url, {
                 title: nextTrack.title,
                 duration: nextTrack.duration,
                 requester: nextTrack.requester,
                 requesterId: nextTrack.requesterId,
                 thumbnail: nextTrack.thumbnail,
-                source: nextTrack.source
+                source: nextTrack.source,
+                isTempFile: nextTrack.isTempFile
             });
-
             return true;
         } catch (error) {
             console.error('Error playing next track:', error);
@@ -447,21 +482,15 @@ class IcecastQueue {
         if (!this.streamer.isStreaming && this.streamer.isFallbackActive) {
             return false;
         }
-
         this.skipRequested = true;
         this.streamer.stop();
-
         await this.delay(100);
         await this.playNext();
-
         return true;
     }
 
     remove(position) {
-        if (position < 1 || position > this.queue.length) {
-            return null;
-        }
-
+        if (position < 1 || position > this.queue.length) return null;
         return this.queue.splice(position - 1, 1)[0];
     }
 
@@ -470,7 +499,6 @@ class IcecastQueue {
             toIndex < 0 || toIndex >= this.queue.length) {
             return false;
         }
-
         const track = this.queue.splice(fromIndex, 1)[0];
         this.queue.splice(toIndex, 0, track);
         return true;
@@ -485,24 +513,19 @@ class IcecastQueue {
     clear() {
         const cleared = [...this.queue];
         this.queue = [];
-
         this.checkAndStartFallback();
-
         return cleared;
     }
 
     addToHistory(track, success = true) {
         if (track.isFallback) return;
-
         const historyEntry = {
             ...track,
             playedAt: Date.now(),
             success,
             endedAt: Date.now()
         };
-
         this.history.unshift(historyEntry);
-
         if (this.history.length > this.maxHistory) {
             this.history.pop();
         }
@@ -542,64 +565,102 @@ class IcecastQueue {
 }
 
 class YouTubeExtractor {
-    static async getStreamUrl(youtubeUrl) {
-        return new Promise((resolve) => {
-            const ytdlp = spawn('yt-dlp', [
+    static async downloadAudioToTempFile(youtubeUrl) {
+        return new Promise((resolve, reject) => {
+            const tempPath = path.join(os.tmpdir(), `yt-${Date.now()}-${Math.random().toString(36).substring(2, 10)}.webm`);
+
+            // First, get metadata using --print (like your original getStreamUrl)
+            const metaProc = spawn('yt-dlp', [
                 youtubeUrl,
                 '--print', '%(url)s',
                 '--print', '%(title)s',
                 '--print', '%(duration)s',
                 '--print', '%(thumbnail)s',
-                '-f', 'bestaudio[ext=m4a]/bestaudio',
                 '--no-playlist',
                 '--no-check-certificates',
                 '--quiet'
-            ], {
-                timeout: 15000
-            });
+            ], { timeout: 15000 });
 
-            let data = '';
-            ytdlp.stdout.on('data', (chunk) => data += chunk.toString());
-            ytdlp.stderr.on('data', () => { });
+            let metaData = '';
+            metaProc.stdout.on('data', d => metaData += d.toString());
+            let metaErr = '';
+            metaProc.stderr.on('data', d => metaErr += d.toString());
 
-            ytdlp.on('error', (err) => {
+            metaProc.on('error', (err) => {
                 if (err.code === 'ENOENT') {
-                    reject(new Error('yt-dlp not found. Install with: pip install yt-dlp'));
+                    reject(new Error('yt-dlp not found. Install with: pip install "yt-dlp[default]"'));
                 } else {
                     reject(err);
                 }
             });
 
-            ytdlp.on('timeout', () => {
-                ytdlp.kill('SIGKILL');
-                reject(new Error('YouTube fetch timed out (15s)'));
+            metaProc.on('timeout', () => {
+                metaProc.kill('SIGKILL');
+                reject(new Error('Metadata fetch timed out (15s)'));
             });
 
-            ytdlp.on('close', (code) => {
+            metaProc.on('close', async (code) => {
                 if (code !== 0) {
-                    resolve(null);
+                    reject(new Error(`Failed to fetch YouTube metadata: ${metaErr || 'unknown error'}`));
+                    return;
+                }
+
+                const lines = metaData.trim().split('\n');
+                if (lines.length < 4) {
+                    reject(new Error('Invalid metadata response from yt-dlp'));
                     return;
                 }
 
-                const lines = data.trim().split('\n');
+                const [, title, durStr, thumbnail] = lines;
+                const duration = parseInt(durStr) || 0;
+
+                // Now download the actual audio to temp file
+                const ytdlp = spawn('yt-dlp', [
+                    youtubeUrl,
+                    '-f', 'ba',
+                    '--output', tempPath,
+                    '--no-playlist',
+                    '--no-check-certificates',
+                    '--quiet'
+                ], { timeout: 30000 });
+
+                let stderr = '';
+                ytdlp.stderr.on('data', (chunk) => stderr += chunk.toString());
+
+                ytdlp.on('error', (err) => {
+                    try { fs.unlink(tempPath); } catch { }
+                    reject(err);
+                });
+
+                ytdlp.on('timeout', () => {
+                    ytdlp.kill('SIGKILL');
+                    try { fs.unlink(tempPath); } catch { }
+                    reject(new Error('YouTube download timed out (30s)'));
+                });
+
+                ytdlp.on('close', async (dlCode) => {
+                    if (dlCode !== 0) {
+                        try { await fs.unlink(tempPath); } catch { }
+                        reject(new Error(`yt-dlp download failed: ${stderr}`));
+                        return;
+                    }
 
-                if (lines.length >= 4 && lines[0].startsWith('http')) {
                     resolve({
-                        url: lines[0],
-                        title: lines[1],
-                        duration: parseInt(lines[2]) || 0,
-                        thumbnail: lines[3] || null,
-                        source: 'youtube'
+                        url: tempPath,
+                        title: title || 'Unknown Track',
+                        duration: duration,
+                        thumbnail: thumbnail || null,
+                        source: 'youtube',
+                        isTempFile: true
                     });
-                } else {
-                    resolve(null);
-                }
+                });
             });
         });
     }
 
-    static async searchTrack(query) {
-        return this.getStreamUrl(`ytsearch1:${query}`);
+    static async searchAndDownload(query) {
+        const searchUrl = `ytsearch1:${query}`;
+        return await this.downloadAudioToTempFile(searchUrl);
     }
 }
 
@@ -607,14 +668,13 @@ class IcecastServer {
     constructor(config = {}) {
         this.app = express();
         this.port = config.port || 3000;
-        this.config = config
-        this.logger = config.logger
+        this.config = config;
+        this.logger = config.logger || console;
         this.setupExpress();
     }
 
     setupExpress() {
         this.app.use(express.json());
-
         this.app.get('/stream', (req, res) => {
             res.redirect(this.config.publicStreamUrl);
         });

package/src/classes/Managers/Networking/ConnectionManager.js

@@ -55,7 +55,6 @@ class ConnectionManager extends EventEmitter {
                 [WebSocketConstants.HEADERS.ROOM_ID]: roomId
             },
             handshakeTimeout: WebSocketConstants.DEFAULT_HANDSHAKE_TIMEOUT,
-            autoPong: true
         });
 
         this._setupWebSocketHandlers();
@@ -101,7 +100,7 @@ class ConnectionManager extends EventEmitter {
         this.reconnecting = false;
         this._clearReconnectTimeout();
 
-        this.emit('Connected');
+        this.emit('connected');
         this.logger.info('ConnectionManager', 'WebSocket connection established');
     }
 
@@ -111,7 +110,7 @@ class ConnectionManager extends EventEmitter {
         this.reconnecting = false;
 
         const reasonStr = reason?.toString('utf8') || `Binary reason (length: ${reason?.length || 0})`;
-        this.emit('Disconnected', { code, reason: reasonStr });
+        this.emit('disconnected', { code, reason: reasonStr });
 
         this.logger.warn('ConnectionManager', 'Connection closed', {
             code,
@@ -184,7 +183,7 @@ class ConnectionManager extends EventEmitter {
         }
 
         this.connected = false;
-        this.emit('Disconnected', { code, reason, IsManual: true });
+        this.emit('disconnected', { code, reason, IsManual: true });
     }
 
     send(data) {

package/typings/index.d.ts

@@ -389,11 +389,20 @@ interface EventMap {
 
     // Connections
     error: [data: any]
-    Connected: []
-    Disconnected: [data: DisconnectedData]
+    connected: []
+    disconnected: [data: DisconnectedData]
 }
 
-
+/**
+ * Music event types
+ */
+interface MusicEventMap {
+    MusicStart: [track: Track];
+    MusicEnd: [track: Track];
+    Progress: [data: { position: number, duration: number, percentage: number }];
+    MusicError: [error: Error];
+    StreamEnd: [];
+}
 
 interface CachedUser {
     position: Position;
@@ -1148,19 +1157,6 @@ interface ShuffleResult {
     error?: string;
 }
 
-/**
- * Music event types
- */
-interface MusicEventMap {
-    'playbackStart': [track: Track];
-    'playbackEnd': [track: Track];
-    'progress': [data: { position: number, duration: number, progress: number }];
-    'error': [error: Error];
-    'streamStopped': [];
-    'Ready': [];
-    'ready': [];
-}
-
 /**
  * Logger configuration - controls how bot messages appear in console
  */