streamify-audio 2.0.0

package/src/server.js

@@ -0,0 +1,318 @@
+const express = require('express');
+const youtube = require('./providers/youtube');
+const spotify = require('./providers/spotify');
+const soundcloud = require('./providers/soundcloud');
+const cache = require('./cache');
+const { getActiveStreams, getStreamById, getStreamPosition } = require('./utils/stream');
+const log = require('./utils/logger');
+
+class Server {
+    constructor(config) {
+        this.config = config;
+        this.app = express();
+        this.server = null;
+        this.startTime = null;
+        this.setupRoutes();
+    }
+
+    _isProviderEnabled(provider) {
+        return this.config.providers?.[provider]?.enabled !== false;
+    }
+
+    setupRoutes() {
+        this.app.use(express.json());
+
+        this.app.get('/health', (req, res) => {
+            res.json({
+                status: 'ok',
+                uptime: this.startTime ? Math.floor((Date.now() - this.startTime) / 1000) : 0,
+                activeStreams: getActiveStreams().size
+            });
+        });
+
+        this.app.get('/stats', (req, res) => {
+            const mem = process.memoryUsage();
+            res.json({
+                uptime: this.startTime ? Math.floor((Date.now() - this.startTime) / 1000) : 0,
+                activeStreams: getActiveStreams().size,
+                memory: {
+                    heapUsed: Math.round(mem.heapUsed / 1024 / 1024) + 'MB',
+                    heapTotal: Math.round(mem.heapTotal / 1024 / 1024) + 'MB',
+                    rss: Math.round(mem.rss / 1024 / 1024) + 'MB'
+                },
+                cache: cache.stats(),
+                config: {
+                    spotify: !!this.config.spotify?.clientId,
+                    cookies: !!this.config.cookiesPath
+                }
+            });
+        });
+
+        this.app.get('/streams', (req, res) => {
+            const streams = [];
+            for (const [id, stream] of getActiveStreams()) {
+                streams.push({
+                    id,
+                    source: stream.source,
+                    trackId: stream.videoId || stream.trackId,
+                    position: getStreamPosition(id),
+                    filters: stream.filters || {},
+                    startTime: stream.startTime,
+                    duration: Date.now() - stream.startTime
+                });
+            }
+            res.json({ streams });
+        });
+
+        this.app.get('/streams/:streamId', (req, res) => {
+            const stream = getStreamById(req.params.streamId);
+            if (!stream) {
+                return res.status(404).json({ error: 'Stream not found' });
+            }
+            res.json({
+                id: req.params.streamId,
+                source: stream.source,
+                trackId: stream.videoId || stream.trackId,
+                position: getStreamPosition(req.params.streamId),
+                filters: stream.filters || {},
+                startTime: stream.startTime,
+                duration: Date.now() - stream.startTime
+            });
+        });
+
+        this.app.get('/streams/:streamId/position', (req, res) => {
+            const position = getStreamPosition(req.params.streamId);
+            if (position === null) {
+                return res.status(404).json({ error: 'Stream not found' });
+            }
+            res.json({ position, positionMs: Math.floor(position * 1000) });
+        });
+
+        this.app.get('/youtube/search', async (req, res) => {
+            try {
+                if (!this._isProviderEnabled('youtube')) {
+                    return res.status(400).json({ error: 'YouTube provider is disabled' });
+                }
+                const { q, limit = 10 } = req.query;
+                if (!q) return res.status(400).json({ error: 'Missing query parameter: q' });
+
+                const cacheKey = `yt:search:${q}:${limit}`;
+                const cached = cache.get(cacheKey);
+                if (cached) return res.json(cached);
+
+                const results = await youtube.search(q, parseInt(limit), this.config);
+                cache.set(cacheKey, results, this.config.cache.searchTTL);
+                res.json(results);
+            } catch (error) {
+                log.error('YOUTUBE', 'Search failed:', error.message);
+                res.status(500).json({ error: error.message });
+            }
+        });
+
+        this.app.get('/youtube/info/:videoId', async (req, res) => {
+            try {
+                if (!this._isProviderEnabled('youtube')) {
+                    return res.status(400).json({ error: 'YouTube provider is disabled' });
+                }
+                const { videoId } = req.params;
+
+                const cacheKey = `yt:info:${videoId}`;
+                const cached = cache.get(cacheKey);
+                if (cached) return res.json(cached);
+
+                const info = await youtube.getInfo(videoId, this.config);
+                cache.set(cacheKey, info, this.config.cache.infoTTL);
+                res.json(info);
+            } catch (error) {
+                log.error('YOUTUBE', 'Info failed:', error.message);
+                res.status(500).json({ error: error.message });
+            }
+        });
+
+        this.app.get('/youtube/stream/:videoId', (req, res) => {
+            if (!this._isProviderEnabled('youtube')) {
+                return res.status(400).json({ error: 'YouTube provider is disabled' });
+            }
+            youtube.stream(req.params.videoId, req.query, this.config, res);
+        });
+
+        this.app.get('/spotify/search', async (req, res) => {
+            try {
+                if (!this._isProviderEnabled('spotify')) {
+                    return res.status(400).json({ error: 'Spotify provider is disabled' });
+                }
+                if (!this.config.spotify?.clientId) {
+                    return res.status(400).json({ error: 'Spotify not configured' });
+                }
+                const { q, limit = 10 } = req.query;
+                if (!q) return res.status(400).json({ error: 'Missing query parameter: q' });
+
+                const cacheKey = `sp:search:${q}:${limit}`;
+                const cached = cache.get(cacheKey);
+                if (cached) return res.json(cached);
+
+                const results = await spotify.search(q, parseInt(limit), this.config);
+                cache.set(cacheKey, results, this.config.cache.searchTTL);
+                res.json(results);
+            } catch (error) {
+                log.error('SPOTIFY', 'Search failed:', error.message);
+                res.status(500).json({ error: error.message });
+            }
+        });
+
+        this.app.get('/spotify/info/:trackId', async (req, res) => {
+            try {
+                if (!this._isProviderEnabled('spotify')) {
+                    return res.status(400).json({ error: 'Spotify provider is disabled' });
+                }
+                if (!this.config.spotify?.clientId) {
+                    return res.status(400).json({ error: 'Spotify not configured' });
+                }
+                const { trackId } = req.params;
+
+                const cacheKey = `sp:info:${trackId}`;
+                const cached = cache.get(cacheKey);
+                if (cached) return res.json(cached);
+
+                const info = await spotify.getInfo(trackId, this.config);
+                cache.set(cacheKey, info, this.config.cache.infoTTL);
+                res.json(info);
+            } catch (error) {
+                log.error('SPOTIFY', 'Info failed:', error.message);
+                res.status(500).json({ error: error.message });
+            }
+        });
+
+        this.app.get('/spotify/stream/:trackId', async (req, res) => {
+            try {
+                if (!this._isProviderEnabled('spotify')) {
+                    return res.status(400).json({ error: 'Spotify provider is disabled' });
+                }
+                if (!this.config.spotify?.clientId) {
+                    return res.status(400).json({ error: 'Spotify not configured' });
+                }
+                await spotify.stream(req.params.trackId, req.query, this.config, res);
+            } catch (error) {
+                log.error('SPOTIFY', 'Stream failed:', error.message);
+                res.status(500).json({ error: error.message });
+            }
+        });
+
+        this.app.get('/soundcloud/search', async (req, res) => {
+            try {
+                if (!this._isProviderEnabled('soundcloud')) {
+                    return res.status(400).json({ error: 'SoundCloud provider is disabled' });
+                }
+                const { q, limit = 10 } = req.query;
+                if (!q) return res.status(400).json({ error: 'Missing query parameter: q' });
+
+                const cacheKey = `sc:search:${q}:${limit}`;
+                const cached = cache.get(cacheKey);
+                if (cached) return res.json(cached);
+
+                const results = await soundcloud.search(q, parseInt(limit), this.config);
+                cache.set(cacheKey, results, this.config.cache.searchTTL);
+                res.json(results);
+            } catch (error) {
+                log.error('SOUNDCLOUD', 'Search failed:', error.message);
+                res.status(500).json({ error: error.message });
+            }
+        });
+
+        this.app.get('/soundcloud/stream/:trackId', (req, res) => {
+            if (!this._isProviderEnabled('soundcloud')) {
+                return res.status(400).json({ error: 'SoundCloud provider is disabled' });
+            }
+            soundcloud.stream(req.params.trackId, req.query, this.config, res);
+        });
+
+        this.app.get('/search', async (req, res) => {
+            try {
+                const { q, source = 'youtube', limit = 10 } = req.query;
+                if (!q) return res.status(400).json({ error: 'Missing query parameter: q' });
+
+                let results;
+                switch (source) {
+                    case 'spotify':
+                        if (!this._isProviderEnabled('spotify')) {
+                            return res.status(400).json({ error: 'Spotify provider is disabled' });
+                        }
+                        if (!this.config.spotify?.clientId) {
+                            return res.status(400).json({ error: 'Spotify not configured' });
+                        }
+                        results = await spotify.search(q, parseInt(limit), this.config);
+                        break;
+                    case 'soundcloud':
+                        if (!this._isProviderEnabled('soundcloud')) {
+                            return res.status(400).json({ error: 'SoundCloud provider is disabled' });
+                        }
+                        results = await soundcloud.search(q, parseInt(limit), this.config);
+                        break;
+                    default:
+                        if (!this._isProviderEnabled('youtube')) {
+                            return res.status(400).json({ error: 'YouTube provider is disabled' });
+                        }
+                        results = await youtube.search(q, parseInt(limit), this.config);
+                }
+                res.json(results);
+            } catch (error) {
+                log.error('SEARCH', error.message);
+                res.status(500).json({ error: error.message });
+            }
+        });
+
+        this.app.get('/stream/:source/:id', (req, res) => {
+            const { source, id } = req.params;
+            switch (source) {
+                case 'youtube':
+                    if (!this._isProviderEnabled('youtube')) {
+                        return res.status(400).json({ error: 'YouTube provider is disabled' });
+                    }
+                    youtube.stream(id, req.query, this.config, res);
+                    break;
+                case 'spotify':
+                    if (!this._isProviderEnabled('spotify')) {
+                        return res.status(400).json({ error: 'Spotify provider is disabled' });
+                    }
+                    spotify.stream(id, req.query, this.config, res);
+                    break;
+                case 'soundcloud':
+                    if (!this._isProviderEnabled('soundcloud')) {
+                        return res.status(400).json({ error: 'SoundCloud provider is disabled' });
+                    }
+                    soundcloud.stream(id, req.query, this.config, res);
+                    break;
+                default:
+                    res.status(400).json({ error: 'Invalid source' });
+            }
+        });
+    }
+
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.server = this.app.listen(this.config.port, this.config.host, () => {
+                this.startTime = Date.now();
+                log.success('STREAMIFY', `Running on http://${this.config.host}:${this.config.port}`);
+                log.info('STREAMIFY', `YouTube: ${this._isProviderEnabled('youtube') ? 'enabled' : 'disabled'}`);
+                log.info('STREAMIFY', `Spotify: ${!this._isProviderEnabled('spotify') ? 'disabled' : (this.config.spotify?.clientId ? 'enabled' : 'disabled (no credentials)')}`);
+                log.info('STREAMIFY', `SoundCloud: ${this._isProviderEnabled('soundcloud') ? 'enabled' : 'disabled'}`);
+                log.info('STREAMIFY', `Cookies: ${this.config.cookiesPath ? 'configured' : 'not configured'}`);
+                resolve();
+            });
+
+            this.server.on('error', reject);
+        });
+    }
+
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(resolve);
+            } else {
+                resolve();
+            }
+        });
+    }
+}
+
+module.exports = Server;

package/src/utils/logger.js

@@ -0,0 +1,139 @@
+const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgBlue: '\x1b[44m',
+};
+
+const LOG_LEVELS = {
+    none: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4
+};
+
+let currentLevel = LOG_LEVELS.info;
+let useColors = true;
+
+function setLevel(level) {
+    if (typeof level === 'string') {
+        currentLevel = LOG_LEVELS[level.toLowerCase()] ?? LOG_LEVELS.info;
+    } else if (typeof level === 'number') {
+        currentLevel = level;
+    }
+}
+
+function setColors(enabled) {
+    useColors = enabled;
+}
+
+function colorize(color, text) {
+    if (!useColors) return text;
+    return `${colors[color] || ''}${text}${colors.reset}`;
+}
+
+function formatTime() {
+    const now = new Date();
+    return colorize('gray', `[${now.toTimeString().split(' ')[0]}]`);
+}
+
+function formatTag(tag, color) {
+    return colorize(color, `[${tag}]`);
+}
+
+function debug(tag, ...args) {
+    if (currentLevel < LOG_LEVELS.debug) return;
+    console.log(formatTime(), formatTag(tag, 'gray'), colorize('dim', args.join(' ')));
+}
+
+function info(tag, ...args) {
+    if (currentLevel < LOG_LEVELS.info) return;
+    console.log(formatTime(), formatTag(tag, 'cyan'), ...args);
+}
+
+function success(tag, ...args) {
+    if (currentLevel < LOG_LEVELS.info) return;
+    console.log(formatTime(), formatTag(tag, 'green'), colorize('green', args.join(' ')));
+}
+
+function warn(tag, ...args) {
+    if (currentLevel < LOG_LEVELS.warn) return;
+    console.warn(formatTime(), formatTag(tag, 'yellow'), colorize('yellow', args.join(' ')));
+}
+
+function error(tag, ...args) {
+    if (currentLevel < LOG_LEVELS.error) return;
+    console.error(formatTime(), formatTag(tag, 'red'), colorize('red', args.join(' ')));
+}
+
+function stream(source, id, message) {
+    if (currentLevel < LOG_LEVELS.debug) return;
+    const sourceColor = {
+        youtube: 'red',
+        spotify: 'green',
+        soundcloud: 'yellow'
+    }[source] || 'white';
+
+    console.log(
+        formatTime(),
+        formatTag('STREAM', sourceColor),
+        colorize('dim', `[${id}]`),
+        message
+    );
+}
+
+function banner() {
+    if (currentLevel < LOG_LEVELS.info) return;
+    const text = `
+${colorize('cyan', '╔═══════════════════════════════════════════════╗')}
+${colorize('cyan', '║')}${colorize('bold', '              STREAMIFY v1.0.0                 ')}${colorize('cyan', '║')}
+${colorize('cyan', '║')}   Audio Streaming Library for Discord Bots   ${colorize('cyan', '║')}
+${colorize('cyan', '╚═══════════════════════════════════════════════╝')}`;
+    console.log(text);
+}
+
+function init(config = {}) {
+    if (config.logLevel !== undefined) {
+        setLevel(config.logLevel);
+    } else if (process.env.LOG_LEVEL) {
+        setLevel(process.env.LOG_LEVEL);
+    } else if (process.env.DEBUG === 'true' || process.env.DEBUG === '1') {
+        setLevel('debug');
+    } else if (config.silent || process.env.SILENT === 'true') {
+        setLevel('none');
+    }
+
+    if (config.colors !== undefined) {
+        setColors(config.colors);
+    } else if (process.env.NO_COLOR) {
+        setColors(false);
+    }
+}
+
+module.exports = {
+    debug,
+    info,
+    success,
+    warn,
+    error,
+    stream,
+    banner,
+    setLevel,
+    setColors,
+    init,
+    LOG_LEVELS
+};

package/src/utils/stream.js

@@ -0,0 +1,108 @@
+const activeStreams = new Map();
+let emitter = null;
+
+function setEventEmitter(eventEmitter) {
+    emitter = eventEmitter;
+}
+
+function registerStream(id, streamData) {
+    const data = {
+        ...streamData,
+        startTime: Date.now(),
+        streamStartTime: Date.now(),
+        seekOffset: streamData.filters?.start || 0,
+        paused: false,
+        pausedAt: null
+    };
+    activeStreams.set(id, data);
+
+    if (emitter) {
+        emitter.emit('streamStart', {
+            id,
+            source: streamData.source,
+            trackId: streamData.videoId || streamData.trackId || id,
+            filters: streamData.filters || {},
+            startTime: data.startTime
+        });
+    }
+}
+
+function unregisterStream(id, code = 0, error = null) {
+    const stream = activeStreams.get(id);
+    if (!stream) return;
+
+    activeStreams.delete(id);
+
+    if (emitter) {
+        if (error) {
+            emitter.emit('streamError', {
+                id,
+                source: stream.source,
+                trackId: stream.videoId || stream.trackId || id,
+                filters: stream.filters || {},
+                startTime: stream.startTime,
+                error
+            });
+        } else {
+            emitter.emit('streamEnd', {
+                id,
+                source: stream.source,
+                trackId: stream.videoId || stream.trackId || id,
+                filters: stream.filters || {},
+                startTime: stream.startTime,
+                duration: Date.now() - stream.startTime,
+                code
+            });
+        }
+    }
+}
+
+function getActiveStreams() {
+    return activeStreams;
+}
+
+function getStreamPosition(id) {
+    const stream = activeStreams.get(id);
+    if (!stream) return null;
+
+    const elapsed = (Date.now() - stream.streamStartTime) / 1000;
+    return stream.seekOffset + elapsed;
+}
+
+function getStreamById(id) {
+    return activeStreams.get(id);
+}
+
+function updateStreamFilters(id, newFilters) {
+    const stream = activeStreams.get(id);
+    if (!stream) return null;
+
+    stream.filters = { ...stream.filters, ...newFilters };
+    return stream;
+}
+
+function killAllStreams() {
+    for (const [id, stream] of activeStreams) {
+        if (stream.ytdlp && !stream.ytdlp.killed) {
+            stream.ytdlp.kill('SIGTERM');
+        }
+        if (stream.ffmpeg && !stream.ffmpeg.killed) {
+            stream.ffmpeg.kill('SIGTERM');
+        }
+    }
+    activeStreams.clear();
+}
+
+process.on('SIGTERM', killAllStreams);
+process.on('SIGINT', killAllStreams);
+
+module.exports = {
+    registerStream,
+    unregisterStream,
+    getActiveStreams,
+    getStreamById,
+    getStreamPosition,
+    updateStreamFilters,
+    killAllStreams,
+    setEventEmitter
+};