highrise.bot 1.0.0

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

@@ -0,0 +1,695 @@
+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 = {}) {
+        super();
+        this.config = {
+            server: config.server || 'localhost',
+            port: config.port || 8000,
+            mount: config.mount || '/stream',
+            sourcePassword: config.sourcePassword || 'hackme',
+            fallbackUrl: config.fallbackUrl || '',
+            fallbackEnabled: config.fallbackEnabled || false,
+            audioFormat: config.audioFormat || 'mp3',
+            audioBitrate: config.audioBitrate || '128k',
+            audioSampleRate: config.audioSampleRate || 48000,
+            audioChannels: config.audioChannels || 2,
+            contentType: config.contentType || 'audio/mpeg'
+        };
+
+        this.ffmpegProcess = null;
+        this.fallbackProcess = null;
+        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 = `${this.config.server}:${this.config.port}${this.config.mount}`;
+    }
+
+    getFFmpegArgs(url) {
+        const args = [];
+
+        args.push(
+            '-re',
+            '-i', url,
+            '-f', this.config.audioFormat,
+            '-content_type', this.config.contentType,
+            '-vn',
+            '-ar', this.config.audioSampleRate.toString(),
+            '-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,
+            '-vn',
+            '-ar', this.config.audioSampleRate.toString(),
+            '-ac', this.config.audioChannels.toString(),
+            '-b:a', this.config.audioBitrate,
+            this.icecastUrl
+        ];
+    }
+
+    async streamToIcecast(url, metadata = {}) {
+        if (this.isFallbackActive) {
+            this.stopFallback();
+            await this.delay(200);
+        }
+
+        if (this.ffmpegProcess) {
+            this.stop();
+            await this.delay(200);
+        }
+
+        return new Promise((resolve, reject) => {
+            this.currentTrack = new Track({
+                url,
+                title: metadata.title || 'Unknown Track',
+                duration: metadata.duration || 0,
+                requester: metadata.requester || 'System',
+                requesterId: metadata.requesterId || 'system',
+                thumbnail: metadata.thumbnail,
+                source: metadata.source || 'stream',
+                startedAt: Date.now(),
+                isTempFile: metadata.isTempFile || false
+            });
+
+            if (metadata.isTempFile) {
+                this.tempFilesToDelete.add(url);
+            }
+
+            this.isStreaming = true;
+            this.isFallbackActive = false;
+
+            const args = this.getFFmpegArgs(url);
+            this.ffmpegProcess = spawn('ffmpeg', args);
+
+            this.ffmpegProcess.stderr.on('data', (data) => {
+                const message = data.toString();
+
+                const durationMatch = message.match(/Duration: (\d+):(\d+):(\d+\.\d+)/);
+                if (durationMatch) {
+                    const hours = parseInt(durationMatch[1]);
+                    const minutes = parseInt(durationMatch[2]);
+                    const seconds = parseFloat(durationMatch[3]);
+                    this.currentTrack.duration = hours * 3600 + minutes * 60 + seconds;
+                }
+
+                const timeMatch = message.match(/time=(\d+):(\d+):(\d+\.\d+)/);
+                if (timeMatch) {
+                    const hours = parseInt(timeMatch[1]);
+                    const minutes = parseInt(timeMatch[2]);
+                    const seconds = parseFloat(timeMatch[3]);
+                    this.currentTrack.position = hours * 3600 + minutes * 60 + seconds;
+
+                    this.emit('progress', {
+                        position: this.currentTrack.position,
+                        duration: this.currentTrack.duration,
+                        percentage: this.currentTrack.duration > 0 ?
+                            (this.currentTrack.position / this.currentTrack.duration) * 100 : 0
+                    });
+                }
+
+                if (!this.songEmitted && (message.includes('Stream mapping') || message.includes('Output'))) {
+                    this.songEmitted = true;
+                    this.emit('playbackStart', this.currentTrack);
+                    resolve();
+                }
+
+                if (message.includes('Error') || message.includes('Failed')) {
+                    console.error('FFmpeg error:', message.trim());
+                    this.emit('error', new Error(message.trim()));
+                }
+            });
+
+            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', 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);
+            });
+        });
+    }
+
+    startFallback() {
+        if (!this.config.fallbackUrl || this.isFallbackActive || this.isStreaming) {
+            return false;
+        }
+
+        if (this.ffmpegProcess) {
+            this.ffmpegProcess.kill('SIGKILL');
+            this.ffmpegProcess = null;
+        }
+
+        const args = this.getFallbackFFmpegArgs();
+        this.fallbackProcess = spawn('ffmpeg', args);
+
+        this.isFallbackActive = true;
+        this.isStreaming = false;
+
+        this.currentTrack = new Track({
+            url: this.config.fallbackUrl,
+            title: 'Fallback Music',
+            duration: 0,
+            requester: 'System',
+            requesterId: 'system',
+            source: 'fallback',
+            startedAt: Date.now(),
+            isFallback: true
+        });
+
+        this.fallbackProcess.stderr.on('data', (data) => {
+            const message = data.toString();
+
+            if (!this.fallbackEmitted && (message.includes('Stream mapping') || message.includes('Output'))) {
+                this.fallbackEmitted = true;
+                this.emit('fallbackStart', this.currentTrack);
+            }
+
+            if (message.includes('Error') || message.includes('Failed')) {
+                console.error('Fallback FFmpeg error:', message.trim());
+            }
+        });
+
+        this.fallbackProcess.on('close', (code) => {
+            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;
+        });
+
+        return true;
+    }
+
+    stopFallback() {
+        if (this.fallbackProcess) {
+            this.fallbackProcess.kill('SIGKILL');
+            this.fallbackProcess = null;
+            this.isFallbackActive = false;
+            this.currentTrack = null;
+            this.fallbackEmitted = false;
+            this.emit('fallbackStopped');
+            return true;
+        }
+        return false;
+    }
+
+    stop() {
+        if (this.ffmpegProcess) {
+            this.ffmpegProcess.kill('SIGKILL');
+            this.ffmpegProcess = null;
+            this.isStreaming = false;
+            this.songEmitted = false;
+            this.emit('streamStopped');
+        }
+
+        this.stopFallback();
+    }
+
+    getStatus() {
+        return {
+            isStreaming: this.isStreaming,
+            isFallbackActive: this.isFallbackActive,
+            currentTrack: this.currentTrack,
+            config: this.config,
+            publicStreamUrl: this.publicStreamUrl
+        };
+    }
+
+    getHealth() {
+        return {
+            status: this.isStreaming ? 'playing' :
+                this.isFallbackActive ? 'fallback' : 'idle',
+            latencyMs: this.currentTrack?.startedAt ?
+                Date.now() - this.currentTrack.startedAt : 0,
+            lastError: this.lastError,
+            uptime: this.currentTrack?.startedAt ?
+                (Date.now() - this.currentTrack.startedAt) / 1000 : 0,
+        };
+    }
+
+    getNowPlaying() {
+        if (!this.currentTrack) return null;
+
+        return {
+            track: this.currentTrack,
+            position: this.currentTrack.position || 0,
+            duration: this.currentTrack.duration || 0,
+            progress: this.currentTrack.duration > 0 ?
+                ((this.currentTrack.position || 0) / this.currentTrack.duration) * 100 : 0,
+            remaining: this.currentTrack.duration > 0 ?
+                this.currentTrack.duration - (this.currentTrack.position || 0) : 0,
+            elapsed: this.currentTrack.startedAt ?
+                Math.floor((Date.now() - this.currentTrack.startedAt) / 1000) : 0
+        };
+    }
+
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+        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}`;
+        console.log('Icecast config updated');
+        return this.config;
+    }
+
+    async delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+
+class Track {
+    constructor(data) {
+        this.id = data.id || Date.now();
+        this.url = data.url;
+        this.title = data.title.replace('@', '');
+        this.duration = data.duration;
+        this.requester = data.requester;
+        this.requesterId = data.requesterId;
+        this.addedAt = Date.now();
+        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')}`;
+        }
+        return `${minutes}:${seconds.toString().padStart(2, '0')}`;
+    }
+}
+
+class IcecastQueue {
+    constructor(streamer, config = {}) {
+        this.queue = [];
+        this.streamer = streamer;
+        this.isProcessing = false;
+        this.currentTrack = null;
+        this.loopMode = 'off';
+        this.history = [];
+        this.maxHistory = config.maxHistory || 50;
+        this.skipRequested = false;
+        this.fallbackEnabled = config.fallbackEnabled || false;
+        this.fallbackUrl = config.fallbackUrl || '';
+        this.setupEventListeners();
+        this.checkAndStartFallback();
+    }
+
+    setupEventListeners() {
+        this.streamer.on('playbackEnd', (track) => {
+            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);
+        });
+
+        this.streamer.on('playbackStart', (track) => {
+            this.currentTrack = track;
+        });
+
+        this.streamer.on('fallbackStart', (track) => {
+            this.currentTrack = track;
+        });
+
+        this.streamer.on('fallbackEnd', () => {
+            this.currentTrack = null;
+            this.checkAndStartFallback();
+        });
+    }
+
+    checkAndStartFallback() {
+        if (this.queue.length === 0 &&
+            !this.streamer.isStreaming &&
+            !this.streamer.isFallbackActive &&
+            this.fallbackEnabled &&
+            this.fallbackUrl) {
+            setTimeout(() => {
+                if (this.queue.length === 0 &&
+                    !this.streamer.isStreaming &&
+                    !this.streamer.isFallbackActive) {
+                    this.streamer.startFallback();
+                }
+            }, 1000);
+        }
+    }
+
+    async add(track) {
+        const isNewTrack = !this.queue.some(q => q.id === track.id);
+        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 };
+    }
+
+    async addImmediate(track) {
+        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 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
+
+        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,
+                isTempFile: nextTrack.isTempFile
+            });
+            return true;
+        } catch (error) {
+            console.error('Error playing next track:', error);
+            setTimeout(() => this.playNext(), 1000);
+            return false;
+        } finally {
+            this.isProcessing = false;
+        }
+    }
+
+    async skip() {
+        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;
+        return this.queue.splice(position - 1, 1)[0];
+    }
+
+    move(fromIndex, toIndex) {
+        if (fromIndex < 0 || fromIndex >= this.queue.length ||
+            toIndex < 0 || toIndex >= this.queue.length) {
+            return false;
+        }
+        const track = this.queue.splice(fromIndex, 1)[0];
+        this.queue.splice(toIndex, 0, track);
+        return true;
+    }
+
+    clearExceptCurrent() {
+        const cleared = this.queue.splice(0);
+        this.checkAndStartFallback();
+        return cleared;
+    }
+
+    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();
+        }
+    }
+
+    getQueue() {
+        return [...this.queue];
+    }
+
+    getStatus() {
+        return {
+            isPlaying: this.streamer.isStreaming || this.streamer.isFallbackActive,
+            isMusicPlaying: this.streamer.isStreaming,
+            isFallbackActive: this.streamer.isFallbackActive,
+            currentTrack: this.currentTrack,
+            queueLength: this.queue.length,
+            loopMode: this.loopMode,
+            historyLength: this.history.length,
+            upcoming: this.queue.slice(0, 10)
+        };
+    }
+
+    async delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    startFallback() {
+        if (this.fallbackEnabled && this.fallbackUrl) {
+            return this.streamer.startFallback();
+        }
+        return false;
+    }
+
+    stopFallback() {
+        return this.streamer.stopFallback();
+    }
+}
+
+class YouTubeExtractor {
+    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`);
+
+            const metaProc = spawn('yt-dlp', [
+                youtubeUrl,
+                '--print', '%(url)s',
+                '--print', '%(title)s',
+                '--print', '%(duration)s',
+                '--print', '%(thumbnail)s',
+                '--no-playlist',
+                '--no-check-certificates',
+                '--quiet'
+            ], { timeout: 15000 });
+
+            let metaData = '';
+            metaProc.stdout.on('data', d => metaData += d.toString());
+            let metaErr = '';
+            metaProc.stderr.on('data', d => metaErr += d.toString());
+
+            metaProc.on('error', (err) => {
+                if (err.code === 'ENOENT') {
+                    reject(new Error('yt-dlp not found. Install with: pip install "yt-dlp[default]"'));
+                } else {
+                    reject(err);
+                }
+            });
+
+            metaProc.on('timeout', () => {
+                metaProc.kill('SIGKILL');
+                reject(new Error('Metadata fetch timed out (15s)'));
+            });
+
+            metaProc.on('close', async (code) => {
+                if (code !== 0) {
+                    reject(new Error(`Failed to fetch YouTube metadata: ${metaErr || 'unknown error'} | Code: ${code}`));
+                    return;
+                }
+
+                const lines = metaData.trim().split('\n');
+                if (lines.length < 4) {
+                    reject(new Error('Invalid metadata response from yt-dlp'));
+                    return;
+                }
+
+                const [, title, durStr, thumbnail] = lines;
+                const duration = parseInt(durStr) || 0;
+
+                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;
+                    }
+
+                    resolve({
+                        url: tempPath,
+                        title: title || 'Unknown Track',
+                        duration: duration,
+                        thumbnail: thumbnail || null,
+                        source: 'youtube',
+                        isTempFile: true
+                    });
+                });
+            });
+        });
+    }
+
+    static async searchAndDownload(query) {
+        const searchUrl = `ytsearch1:${query}`;
+        return await this.downloadAudioToTempFile(searchUrl);
+    }
+}
+
+class IcecastServer {
+    constructor(config = {}) {
+        this.app = express();
+        this.port = config.port || 3000;
+        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);
+        });
+    }
+
+    start() {
+        this.app.listen(this.port, () => {
+            this.logger.success(`IcecastServer.start`, `running: http://localhost:${this.port}`);
+            this.logger.success(`IcecastServer.start`, `Icecast Stream: ${this.config.publicStreamUrl}`);
+        });
+    }
+}
+
+module.exports = {
+    IcecastStreamer,
+    IcecastQueue,
+    Track,
+    YouTubeExtractor,
+    IcecastServer
+};