streamify-audio 2.2.5 → 2.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamify-audio",
-  "version": "2.2.5",
+  "version": "2.2.6",
   "description": "Dual-mode audio library: HTTP streaming proxy + Discord player (Lavalink alternative). Supports YouTube, Spotify, SoundCloud with audio filters.",
   "main": "index.js",
   "types": "index.d.ts",

package/src/cache/index.js

@@ -56,6 +56,7 @@ function cleanup() {
     }
 }
 
-setInterval(cleanup, 60000);
+const cleanupInterval = setInterval(cleanup, 60000);
+cleanupInterval.unref();
 
 module.exports = { get, set, del, clear, stats };

package/src/config.js

@@ -68,6 +68,7 @@ function checkYtdlpVersion(ytdlpPath) {
 }
 
 function load(options = {}) {
+    options = options || {};
     let fileConfig = {};
 
     if (options.configPath && fs.existsSync(options.configPath)) {

package/src/discord/Player.js

@@ -382,27 +382,21 @@ class Player extends EventEmitter {
         if (this._prefetching || this.queue.tracks.length === 0) return;
 
         const nextTrack = this.queue.tracks[0];
-        if (!nextTrack || this._prefetchedTrack?.id === nextTrack.id) return;
+        if (!nextTrack || nextTrack._directUrl) return; // Already prefetched or resolved
 
         this._prefetching = true;
-        this._clearPrefetch();
-
-        log.debug('PLAYER', `Prefetching: ${nextTrack.title} (${nextTrack.id})`);
+        log.debug('PLAYER', `Prefetching metadata: ${nextTrack.title}`);
 
         try {
-            const filtersWithVolume = {
-                ...this._filters,
-                volume: this._volume
-            };
-
-            this._prefetchedTrack = nextTrack;
-            this._prefetchedStream = createStream(nextTrack, filtersWithVolume, this.config);
-            await this._prefetchedStream.create();
-
-            log.debug('PLAYER', `Prefetch ready: ${nextTrack.id}`);
+            // Only resolve the metadata and stream URL
+            const result = await this.manager.getInfo(nextTrack.id, nextTrack.source);
+            if (result) {
+                // Merge prefetch data into the existing queue object
+                Object.assign(nextTrack, result);
+                log.debug('PLAYER', `Prefetch ready (Metadata only): ${nextTrack.id}`);
+            }
         } catch (error) {
             log.debug('PLAYER', `Prefetch failed: ${error.message}`);
-            this._clearPrefetch();
         } finally {
             this._prefetching = false;
         }

package/src/discord/Stream.js

@@ -96,6 +96,11 @@ class StreamController {
             // Skip yt-dlp for local files
             ffmpegIn = 'pipe:0'; // We'll just pass the file path to ffmpeg -i
             this.metrics.spawn = Date.now() - spawnStart;
+        } else if (this.track._directUrl && !isLive && seekPosition === 0) {
+            // OPTIMIZATION: Bypass yt-dlp if we already have a direct stream URL
+            ffmpegIn = this.track._directUrl;
+            log.info('STREAM', `Bypassing yt-dlp, using direct URL for ${videoId}`);
+            this.metrics.spawn = 0;
         } else {
             let url;
             if (source === 'soundcloud') {
@@ -157,15 +162,31 @@ class StreamController {
         const ffmpegFilters = { ...this.filters };
         const ffmpegArgs = buildFfmpegArgs(ffmpegFilters, this.config);
         
-        // If local, inject the input file before other args
+        // Input injection - only override if NOT using pipe:0 (buildFfmpegArgs already includes -i pipe:0)
         if (isLocal) {
             const filePath = this.track.absolutePath || videoId.replace('file://', '');
-            ffmpegArgs.unshift('-i', filePath);
-            if (seekPosition > 0) {
-                const seekSeconds = (seekPosition / 1000).toFixed(3);
-                ffmpegArgs.unshift('-ss', seekSeconds);
+            const pipeIndex = ffmpegArgs.indexOf('pipe:0');
+            if (pipeIndex > 0) {
+                ffmpegArgs[pipeIndex] = filePath;
+                if (seekPosition > 0) {
+                    const seekSeconds = (seekPosition / 1000).toFixed(3);
+                    ffmpegArgs.splice(pipeIndex - 1, 0, '-ss', seekSeconds);
+                }
+            }
+        } else if (ffmpegIn !== 'pipe:0') {
+            // Direct URL - replace the pipe:0 input with the direct URL
+            const pipeIndex = ffmpegArgs.indexOf('pipe:0');
+            if (pipeIndex > 0) {
+                ffmpegArgs[pipeIndex] = ffmpegIn;
+                if (this.track._headers) {
+                    const headers = Object.entries(this.track._headers)
+                        .map(([k, v]) => `${k}: ${v}`)
+                        .join('\r\n');
+                    ffmpegArgs.splice(pipeIndex - 1, 0, '-headers', headers);
+                }
             }
         }
+        // else: pipe:0 - buildFfmpegArgs already has -i pipe:0, nothing to change
 
         this.ffmpeg = spawn(this.config.ffmpegPath, ffmpegArgs, { env });
         this.metrics.spawn = Date.now() - spawnStart;
@@ -225,6 +246,7 @@ class StreamController {
     _waitForData(isLive = false) {
         const ffmpeg = this.ffmpeg;
         const ytdlp = this.ytdlp;
+        const MIN_BUFFER_SIZE = 32 * 1024;
 
         return new Promise((resolve, reject) => {
             if (!ffmpeg) return resolve();
@@ -236,28 +258,37 @@ class StreamController {
             }, timeoutMs);
 
             let resolved = false;
+            let bufferedSize = 0;
+            let firstByteRecorded = false;
 
-            // USE READABLE EVENT: Zero-consumption way to detect data
-            const onReadable = () => {
-                if (!resolved) {
+            const checkBuffer = () => {
+                if (resolved) return;
+
+                if (!firstByteRecorded && ffmpeg.stdout && ffmpeg.stdout.readableLength > 0) {
+                    firstByteRecorded = true;
+                    this.metrics.firstByte = Date.now() - (this.startTime + this.metrics.metadata + this.metrics.spawn);
+                }
+
+                bufferedSize = ffmpeg.stdout ? ffmpeg.stdout.readableLength : 0;
+
+                if (bufferedSize >= MIN_BUFFER_SIZE) {
                     resolved = true;
                     clearTimeout(timeout);
-                    this.metrics.firstByte = Date.now() - (this.startTime + this.metrics.metadata + this.metrics.spawn);
-                    if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
+                    if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', checkBuffer);
                     resolve();
                 }
             };
 
             if (ffmpeg.stdout) {
-                ffmpeg.stdout.on('readable', onReadable);
+                ffmpeg.stdout.on('readable', checkBuffer);
             }
 
             ffmpeg.on('close', () => {
                 if (!resolved) {
                     resolved = true;
                     clearTimeout(timeout);
-                    if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
-                    
+                    if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', checkBuffer);
+
                     if (this.destroyed) {
                         return reject(new Error('Stream destroyed during initialization'));
                     }
@@ -272,12 +303,12 @@ class StreamController {
                     if (!resolved && code !== 0 && code !== null) {
                         resolved = true;
                         clearTimeout(timeout);
-                        if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
+                        if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', checkBuffer);
 
                         if (this.destroyed) {
                             return reject(new Error('Stream destroyed during initialization'));
                         }
-                        
+
                         reject(new Error(`yt-dlp failed with code ${code}`));
                     }
                 });

package/src/filters/ffmpeg.js

@@ -67,14 +67,18 @@ function buildEqualizer(bands) {
 }
 
 function buildFfmpegArgs(filters = {}, config = {}) {
+    filters = filters || {};
     const args = [
         '-thread_queue_size', '4096',
+        '-probesize', '128K',
+        '-analyzeduration', '0',
+        '-fflags', '+discardcorrupt',
         '-copyts',
         '-start_at_zero',
         '-i', 'pipe:0',
         '-vn'
     ];
-    const audioFilters = [];
+    const audioFilters = ['aresample=async=1:first_pts=0'];
 
     if (filters.equalizer && Array.isArray(filters.equalizer)) {
         const eq = buildEqualizer(filters.equalizer);

package/src/providers/http.js

@@ -3,10 +3,20 @@ const log = require('../utils/logger');
 async function getInfo(url, config) {
     log.info('HTTP', `Getting info for direct URL: ${url}`);
 
-    // For direct URLs, we can't easily get metadata without downloading or using ffprobe
-    // For now, we'll return a basic object. 
-    // In a full implementation, we might use ffprobe here.
-    
+    if (!url || typeof url !== 'string') {
+        throw new Error('Invalid URL: URL must be a non-empty string');
+    }
+
+    try {
+        new URL(url);
+    } catch (e) {
+        throw new Error(`Invalid URL format: ${url}`);
+    }
+
+    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+        throw new Error(`Invalid URL protocol: ${url}`);
+    }
+
     const filename = url.split('/').pop().split('?')[0] || 'Direct Audio';
 
     return {

package/src/providers/local.js

@@ -12,6 +12,11 @@ async function getInfo(filePath, config) {
         throw new Error(`File not found: ${absolutePath}`);
     }
 
+    const stats = fs.statSync(absolutePath);
+    if (stats.isDirectory()) {
+        throw new Error(`Path is a directory, not a file: ${absolutePath}`);
+    }
+
     const filename = path.basename(absolutePath);
 
     return {

package/src/providers/youtube.js

@@ -46,6 +46,10 @@ async function search(query, limit, config, options = {}) {
         let stdout = '';
         let stderr = '';
 
+        proc.on('error', (err) => {
+            reject(new Error(`yt-dlp spawn error: ${err.message}`));
+        });
+
         proc.stdout.on('data', (data) => { stdout += data; });
         proc.stderr.on('data', (data) => { stderr += data; });
 
@@ -55,17 +59,25 @@ async function search(query, limit, config, options = {}) {
             }
             try {
                 const data = JSON.parse(stdout);
-                const tracks = (data.entries || []).map(entry => ({
-                    id: entry.id,
-                    title: entry.title,
-                    duration: entry.duration || 0,
-                    author: entry.channel || entry.uploader,
-                    thumbnail: entry.thumbnails?.[0]?.url,
-                    uri: `https://www.youtube.com/watch?v=${entry.id}`,
-                    streamUrl: `/youtube/stream/${entry.id}`,
-                    source: 'youtube',
-                    isLive: entry.live_status === 'is_live' || entry.is_live === true || !entry.duration
-                }));
+                const tracks = (data.entries || []).map(entry => {
+                    const bestAudio = entry.formats
+                        ?.filter(f => f.vcodec === 'none' && f.acodec !== 'none')
+                        .sort((a, b) => (b.abr || 0) - (a.abr || 0))[0];
+
+                    return {
+                        id: entry.id,
+                        title: entry.title,
+                        duration: entry.duration || 0,
+                        author: entry.channel || entry.uploader,
+                        thumbnail: entry.thumbnails?.[0]?.url,
+                        uri: `https://www.youtube.com/watch?v=${entry.id}`,
+                        streamUrl: `/youtube/stream/${entry.id}`,
+                        source: 'youtube',
+                        isLive: entry.live_status === 'is_live' || entry.is_live === true || !entry.duration,
+                        _directUrl: bestAudio?.url || null,
+                        _headers: entry.http_headers || data.http_headers || null
+                    };
+                });
                 const elapsed = Date.now() - startTime;
                 log.info('YOUTUBE', `Found ${tracks.length} results (${elapsed}ms)`);
                 resolve({ tracks, source: 'youtube', searchTime: elapsed });
@@ -108,6 +120,12 @@ async function getInfo(videoId, config) {
             try {
                 const data = JSON.parse(stdout);
                 const isLive = data.live_status === 'is_live' || data.is_live === true || !data.duration;
+                
+                // Extract best audio-only format for direct piping
+                const bestAudio = data.formats
+                    ?.filter(f => f.vcodec === 'none' && f.acodec !== 'none')
+                    .sort((a, b) => (b.abr || 0) - (a.abr || 0))[0];
+
                 resolve({
                     id: data.id,
                     title: data.title,
@@ -117,7 +135,9 @@ async function getInfo(videoId, config) {
                     uri: data.webpage_url,
                     streamUrl: `/youtube/stream/${data.id}`,
                     source: 'youtube',
-                    isLive
+                    isLive,
+                    _directUrl: bestAudio?.url || null,
+                    _headers: data.http_headers || null
                 });
             } catch (e) {
                 reject(new Error('Failed to parse yt-dlp output'));

package/tests/cache.test.js

@@ -0,0 +1,234 @@
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert');
+
+const cache = require('../src/cache');
+
+describe('Cache', () => {
+    beforeEach(() => {
+        cache.clear();
+    });
+
+    afterEach(() => {
+        cache.clear();
+    });
+
+    describe('set and get', () => {
+        it('should store and retrieve values', () => {
+            cache.set('key1', 'value1');
+            assert.strictEqual(cache.get('key1'), 'value1');
+        });
+
+        it('should store complex objects', () => {
+            const obj = { id: 1, data: { nested: true }, arr: [1, 2, 3] };
+            cache.set('obj', obj);
+            assert.deepStrictEqual(cache.get('obj'), obj);
+        });
+
+        it('should store arrays', () => {
+            const arr = [1, 2, 3, { a: 1 }];
+            cache.set('arr', arr);
+            assert.deepStrictEqual(cache.get('arr'), arr);
+        });
+
+        it('should store null values', () => {
+            cache.set('null', null);
+            assert.strictEqual(cache.get('null'), null);
+        });
+
+        it('should store zero', () => {
+            cache.set('zero', 0);
+            assert.strictEqual(cache.get('zero'), 0);
+        });
+
+        it('should store empty string', () => {
+            cache.set('empty', '');
+            assert.strictEqual(cache.get('empty'), '');
+        });
+
+        it('should store false', () => {
+            cache.set('false', false);
+            assert.strictEqual(cache.get('false'), false);
+        });
+
+        it('should overwrite existing values', () => {
+            cache.set('key', 'value1');
+            cache.set('key', 'value2');
+            assert.strictEqual(cache.get('key'), 'value2');
+        });
+
+        it('should return null for non-existent keys', () => {
+            assert.strictEqual(cache.get('nonexistent'), null);
+        });
+    });
+
+    describe('TTL expiration', () => {
+        it('should expire after TTL', async () => {
+            cache.set('expiring', 'value', 0.1);
+            assert.strictEqual(cache.get('expiring'), 'value');
+
+            await new Promise(r => setTimeout(r, 150));
+
+            assert.strictEqual(cache.get('expiring'), null);
+        });
+
+        it('should use default TTL of 300 seconds', () => {
+            cache.set('default', 'value');
+            const stats = cache.stats();
+            assert.strictEqual(stats.valid, 1);
+        });
+
+        it('should handle zero TTL', async () => {
+            cache.set('zero-ttl', 'value', 0);
+
+            await new Promise(r => setTimeout(r, 10));
+
+            assert.strictEqual(cache.get('zero-ttl'), null);
+        });
+
+        it('should handle negative TTL as immediate expiration', async () => {
+            cache.set('negative-ttl', 'value', -1);
+
+            await new Promise(r => setTimeout(r, 10));
+
+            assert.strictEqual(cache.get('negative-ttl'), null);
+        });
+    });
+
+    describe('del', () => {
+        it('should delete existing keys', () => {
+            cache.set('key', 'value');
+            cache.del('key');
+            assert.strictEqual(cache.get('key'), null);
+        });
+
+        it('should not throw for non-existent keys', () => {
+            assert.doesNotThrow(() => cache.del('nonexistent'));
+        });
+    });
+
+    describe('clear', () => {
+        it('should remove all entries', () => {
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+            cache.set('key3', 'value3');
+
+            cache.clear();
+
+            assert.strictEqual(cache.get('key1'), null);
+            assert.strictEqual(cache.get('key2'), null);
+            assert.strictEqual(cache.get('key3'), null);
+        });
+
+        it('should reset stats', () => {
+            cache.set('key1', 'value1');
+            cache.clear();
+
+            const stats = cache.stats();
+            assert.strictEqual(stats.entries, 0);
+        });
+    });
+
+    describe('stats', () => {
+        it('should count valid entries', () => {
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+
+            const stats = cache.stats();
+            assert.strictEqual(stats.entries, 2);
+            assert.strictEqual(stats.valid, 2);
+            assert.strictEqual(stats.expired, 0);
+        });
+
+        it('should count expired entries', async () => {
+            cache.set('expiring', 'value', 0.05);
+            cache.set('valid', 'value', 300);
+
+            await new Promise(r => setTimeout(r, 100));
+
+            const stats = cache.stats();
+            assert.strictEqual(stats.entries, 2);
+            assert.strictEqual(stats.valid, 1);
+            assert.strictEqual(stats.expired, 1);
+        });
+
+        it('should return zero for empty cache', () => {
+            const stats = cache.stats();
+            assert.strictEqual(stats.entries, 0);
+            assert.strictEqual(stats.valid, 0);
+            assert.strictEqual(stats.expired, 0);
+        });
+    });
+
+    describe('edge cases', () => {
+        it('should handle special characters in keys', () => {
+            cache.set('key:with:colons', 'value');
+            cache.set('key/with/slashes', 'value');
+            cache.set('key with spaces', 'value');
+            cache.set('key\nwith\nnewlines', 'value');
+
+            assert.strictEqual(cache.get('key:with:colons'), 'value');
+            assert.strictEqual(cache.get('key/with/slashes'), 'value');
+            assert.strictEqual(cache.get('key with spaces'), 'value');
+            assert.strictEqual(cache.get('key\nwith\nnewlines'), 'value');
+        });
+
+        it('should handle unicode keys', () => {
+            cache.set('日本語キー', 'value');
+            cache.set('emoji🎵key', 'value');
+
+            assert.strictEqual(cache.get('日本語キー'), 'value');
+            assert.strictEqual(cache.get('emoji🎵key'), 'value');
+        });
+
+        it('should handle very long keys', () => {
+            const longKey = 'a'.repeat(10000);
+            cache.set(longKey, 'value');
+            assert.strictEqual(cache.get(longKey), 'value');
+        });
+
+        it('should handle very large values', () => {
+            const largeValue = { data: 'x'.repeat(100000) };
+            cache.set('large', largeValue);
+            assert.deepStrictEqual(cache.get('large'), largeValue);
+        });
+
+        it('should handle undefined key gracefully', () => {
+            assert.strictEqual(cache.get(undefined), null);
+        });
+
+        it('should handle null key gracefully', () => {
+            assert.strictEqual(cache.get(null), null);
+        });
+    });
+
+    describe('concurrency simulation', () => {
+        it('should handle rapid set/get operations', () => {
+            for (let i = 0; i < 1000; i++) {
+                cache.set(`key${i}`, `value${i}`);
+            }
+
+            for (let i = 0; i < 1000; i++) {
+                assert.strictEqual(cache.get(`key${i}`), `value${i}`);
+            }
+
+            const stats = cache.stats();
+            assert.strictEqual(stats.entries, 1000);
+        });
+
+        it('should handle interleaved set/get/del', () => {
+            for (let i = 0; i < 100; i++) {
+                cache.set(`key${i}`, `value${i}`);
+                if (i % 2 === 0) {
+                    cache.del(`key${i}`);
+                }
+            }
+
+            let found = 0;
+            for (let i = 0; i < 100; i++) {
+                if (cache.get(`key${i}`) !== null) found++;
+            }
+
+            assert.strictEqual(found, 50);
+        });
+    });
+});