streamify-audio 2.1.16 → 2.1.22

package/README.md

@@ -171,23 +171,48 @@ audio.play();
 | Feature | Discord | HTTP |
 |---------|:-------:|:----:|
 | 🎵 YouTube, Spotify, SoundCloud | ✅ | ✅ |
+| 📺 **Voice Channel Status** | ✅ | — |
+| 🔍 **Advanced Search Filters** | ✅ | ✅ |
 | 📋 Playlists & Albums | ✅ | ✅ |
-| 🎚️ 25+ Audio Filters | ✅ | ✅ |
+| 🎚️ 30+ Stackable Filters | ✅ | ✅ |
 | 🎛️ 15-Band Equalizer | ✅ | ✅ |
 | 🎨 15 EQ Presets | ✅ | ✅ |
 | ⏭️ Instant Skip (prefetch) | ✅ | — |
 | ⏸️ Auto-pause when alone | ✅ | — |
 | ▶️ Auto-resume on rejoin | ✅ | — |
 | 🚪 Auto-leave on inactivity | ✅ | — |
-| 📻 Autoplay related tracks | ✅ | — |
 | 🚫 Sponsorblock | ✅ | ✅ |
-| 📊 Stream position tracking | ✅ | ✅ |
+| 📊 Timing & Performance Logs | ✅ | ✅ |
 | 🔌 No Lavalink/Java needed | ✅ | ✅ |
 
 ---
 
 ## 🎮 Discord Player Features
 
+### Voice Channel Status
+
+Show what's playing directly in the sidebar of the voice channel.
+
+```javascript
+const manager = new Streamify.Manager(client, {
+    voiceChannelStatus: {
+        enabled: true,
+        template: '🎶 Playing: {title} | {requester}'
+    }
+});
+```
+
+### Search with Filters
+
+Filter for live streams or sort results by popularity/date.
+
+```javascript
+const results = await manager.search('lofi hip hop', {
+    type: 'live',
+    sort: 'popularity'
+});
+```
+
 ### Queue Management
 
 ```javascript
@@ -297,6 +322,10 @@ const url = streamify.getStreamUrl('youtube', 'dQw4w9WgXcQ', {
 | `volume` | 0 to 200 | Volume % |
 | `nightcore` | boolean | Speed + pitch up |
 | `vaporwave` | boolean | Speed + pitch down |
+| `subboost` | boolean | Extreme sub-bass boost |
+| `reverb` | boolean | Room acoustics effect |
+| `surround` | boolean | Surround sound mapping |
+| `boost` | boolean | Clarity & volume boost |
 | `8d` | boolean | Rotating audio |
 | `karaoke` | boolean | Reduce vocals |
 | `bassboost` | boolean | Heavy bass |

package/docs/configuration.md

@@ -57,10 +57,21 @@ const manager = new Streamify.Manager(client, {
     autoplay: {
         enabled: false,
         maxTracks: 5              // Related tracks to fetch
+    },
+
+    // Voice Channel Status
+    voiceChannelStatus: {
+        enabled: true,            // Show "Now Playing" in VC description
+        template: '🎶 Now Playing: {title} - {artist}' // Custom template
     }
 });
 ```
 
+**Voice Channel Status Template Variables:**
+- `{title}` - Track title
+- `{artist}` - Track artist/author
+- `{requester}` - Username of the requester (if provided)
+
 ## HTTP Server Mode
 
 ```javascript

package/docs/discord/manager.md

@@ -70,15 +70,22 @@ process.on('SIGINT', () => {
 
 Searches for tracks.
 
-```javascript
-// Basic search (YouTube)
-const result = await manager.search('never gonna give you up');
+- `query` (string) - The search term or URL
+- `options` (object) - Search configuration
+    - `source` (string) - `youtube`, `spotify`, or `soundcloud`
+    - `limit` (number) - Number of results (default: 10)
+    - `type` (string) - `video`, `live`, or `all` (YouTube only)
+    - `sort` (string) - `relevance`, `popularity`, `date`, or `rating` (YouTube only)
+
+**Example:**
 
-// With options
-const result = await manager.search('never gonna give you up', {
-    source: 'spotify',  // youtube, spotify, soundcloud
-    limit: 10
+```javascript
+const result = await manager.search('lofi hip hop', {
+    source: 'youtube',
+    type: 'live',
+    sort: 'popularity'
 });
+```
 
 // Result
 {

package/docs/discord/player.md

@@ -163,6 +163,10 @@ const presets = player.getEffectPresets();
 - `vaporwave` - Slow down with lower pitch
 - `8d` - 8D rotating audio effect
 - `karaoke` - Reduce vocals
+- `reverb` - Add room acoustics / echo
+- `surround` - Virtual surround sound mapping
+- `boost` - General volume and clarity boost
+- `subboost` - Extreme sub-woofer boost
 - `trebleboost` - Boost treble frequencies
 - `deep` - Deep bass with lower pitch
 - `lofi` - Lo-fi aesthetic

package/docs/filters.md

@@ -287,6 +287,44 @@ await player.setFilter('peaking', {
 });
 ```
 
+## Effect Presets (Stacked)
+
+Streamify supports "Effect Presets" which can be stacked on top of each other. These are more powerful than standard filters because they can combine multiple FFmpeg settings.
+
+### Available Effect Presets
+
+| Preset | Description |
+|--------|-------------|
+| `bassboost` | Strong low-end boost |
+| `subboost` | Extreme sub-woofer boost |
+| `nightcore` | High speed and pitch |
+| `vaporwave` | Low speed and pitch |
+| `reverb` | Adds room acoustics / echo |
+| `surround` | Virtual surround sound mapping |
+| `boost` | General volume and clarity boost |
+| `karaoke` | Vocal reduction |
+| `8d` | Fast circular panning |
+
+### Usage
+
+```javascript
+// Set a single effect with intensity (0.0 to 2.0)
+await player.setEffectPresets({ name: 'reverb', intensity: 0.8 });
+
+// Stack multiple effects
+await player.setEffectPresets([
+    { name: 'bassboost', intensity: 1.2 },
+    { name: 'nightcore', intensity: 1.0 }
+]);
+
+// Clear all effects
+await player.clearEffectPresets();
+
+// Get active effects
+const active = player.getActiveEffectPresets();
+// [{ name: 'reverb', intensity: 0.8 }]
+```
+
 ## Additional Effects
 
 | Effect | Description |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamify-audio",
-  "version": "2.1.16",
+  "version": "2.1.22",
   "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/config.js

@@ -18,6 +18,10 @@ const defaults = {
         clientId: null,
         clientSecret: null
     },
+    voiceChannelStatus: {
+        enabled: false,
+        template: '🎶 Now Playing: {title} - {artist} | Requested by: {requester}'
+    },
     audio: {
         bitrate: '128k',
         format: 'opus'

package/src/discord/Manager.js

@@ -73,6 +73,11 @@ class Manager extends EventEmitter {
             maxTracks: options.autoplay?.maxTracks ?? 5
         };
 
+        this.voiceChannelStatus = {
+            enabled: options.voiceChannelStatus?.enabled ?? false,
+            template: options.voiceChannelStatus?.template ?? '🎶 Now Playing: {title} - {artist} | Requested by: {requester}'
+        };
+
         this._setupVoiceStateListener();
 
         log.info('MANAGER', 'Streamify Manager initialized');
@@ -91,6 +96,10 @@ class Manager extends EventEmitter {
             }
 
             if (oldState.id === botId && newState.channelId && oldState.channelId !== newState.channelId) {
+                // Clear status of the old channel
+                if (oldState.channelId) {
+                    this.clearVoiceStatus(oldState.channelId);
+                }
                 player.voiceChannelId = newState.channelId;
                 player.emit('channelMove', newState.channelId);
                 return;
@@ -103,12 +112,16 @@ class Manager extends EventEmitter {
                 const members = channel.members.filter(m => !m.user.bot);
                 const memberCount = members.size;
 
-                if (oldState.channelId === player.voiceChannelId && newState.channelId !== player.voiceChannelId) {
-                    player.emit('userLeave', oldState.member, memberCount);
-                }
+                // Ignore bots for join/leave events
+                const transitionedMember = newState.member || oldState.member;
+                if (transitionedMember && !transitionedMember.user.bot) {
+                    if (oldState.channelId === player.voiceChannelId && newState.channelId !== player.voiceChannelId) {
+                        player.emit('userLeave', transitionedMember, memberCount);
+                    }
 
-                if (newState.channelId === player.voiceChannelId && oldState.channelId !== player.voiceChannelId) {
-                    player.emit('userJoin', newState.member, memberCount);
+                    if (newState.channelId === player.voiceChannelId && oldState.channelId !== player.voiceChannelId) {
+                        player.emit('userJoin', transitionedMember, memberCount);
+                    }
                 }
 
                 if (memberCount < player.autoPause.minUsers) {
@@ -165,7 +178,8 @@ class Manager extends EventEmitter {
             maxPreviousTracks: this.maxPreviousTracks,
             autoLeave: this.autoLeave,
             autoPause: this.autoPause,
-            autoplay: this.autoplay
+            autoplay: this.autoplay,
+            voiceChannelStatus: this.voiceChannelStatus
         });
 
         player.on('destroy', () => {
@@ -184,6 +198,20 @@ class Manager extends EventEmitter {
         return this.players.get(guildId);
     }
 
+    async clearVoiceStatus(channelId) {
+        if (!channelId) return false;
+        try {
+            await this.client.rest.put(`/channels/${channelId}/voice-status`, {
+                body: { status: "" }
+            });
+            log.debug('MANAGER', `Cleared voice status for channel ${channelId}`);
+            return true;
+        } catch (error) {
+            log.debug('MANAGER', `Failed to clear voice status for ${channelId}: ${error.message}`);
+            return false;
+        }
+    }
+
     destroy(guildId) {
         const player = this.players.get(guildId);
         if (player) {

package/src/discord/Player.js

@@ -65,10 +65,16 @@ class Player extends EventEmitter {
             maxTracks: options.autoplay?.maxTracks ?? 5
         };
 
+        this.voiceChannelStatus = {
+            enabled: options.voiceChannelStatus?.enabled ?? false,
+            template: options.voiceChannelStatus?.template ?? '🎶 Now Playing: {title} - {artist} | Requested by: {requester}'
+        };
+
         this._emptyTimeout = null;
         this._inactivityTimeout = null;
         this._lastActivity = Date.now();
         this._autoPaused = false;
+        this._lastStatusUpdate = 0;
     }
 
     setAutoPause(enabled) {
@@ -206,6 +212,7 @@ class Player extends EventEmitter {
                     if (this.autoplay.enabled && track) {
                         await this._handleAutoplay(track);
                     } else {
+                        this._clearVoiceChannelStatus();
                         this.emit('queueEnd');
                         this._resetInactivityTimeout();
                     }
@@ -241,6 +248,7 @@ class Player extends EventEmitter {
                 // Use setImmediate to break recursion stack on consecutive failures
                 setImmediate(() => this._playTrack(next));
             } else {
+                this._clearVoiceChannelStatus();
                 this.emit('queueEnd');
             }
         });
@@ -332,6 +340,7 @@ class Player extends EventEmitter {
             this._positionTimestamp = Date.now();
 
             this._prefetchNext();
+            setImmediate(() => this._updateVoiceChannelStatus(track));
 
             return track;
         } catch (error) {
@@ -352,6 +361,14 @@ class Player extends EventEmitter {
         }
     }
 
+    _clearPrefetch() {
+        if (this._prefetchedStream) {
+            this._prefetchedStream.destroy();
+            this._prefetchedStream = null;
+        }
+        this._prefetchedTrack = null;
+    }
+
     async _prefetchNext() {
         if (this._prefetching || this.queue.tracks.length === 0) return;
 
@@ -382,12 +399,57 @@ class Player extends EventEmitter {
         }
     }
 
-    _clearPrefetch() {
-        if (this._prefetchedStream) {
-            this._prefetchedStream.destroy();
-            this._prefetchedStream = null;
+    async _updateVoiceChannelStatus(track, force = false) {
+        if (!this.voiceChannelStatus.enabled || !track) return;
+
+        const now = Date.now();
+        if (!force && now - this._lastStatusUpdate < 300000) {
+            log.debug('PLAYER', 'Skipping voice channel status update due to rate limit');
+            return;
+        }
+
+        const guild = this.manager.client.guilds.cache.get(this.guildId);
+        const channel = guild?.channels.cache.get(this.voiceChannelId);
+        if (!channel) return;
+
+        const botMember = guild.members.me || guild.members.cache.get(this.manager.client.user.id);
+        if (!channel.permissionsFor(botMember)?.has('ManageChannels')) {
+            log.warn('PLAYER', `Missing 'ManageChannels' permission to update status in ${channel.name}`);
+            return;
+        }
+
+        try {
+            const requesterName = typeof track.requestedBy === 'string' ? track.requestedBy : (track.requestedBy?.username || 'Unknown');
+            const statusText = this.voiceChannelStatus.template
+                .replace('{title}', track.title || 'Unknown')
+                .replace('{artist}', track.author || 'Unknown')
+                .replace('{requester}', requesterName)
+                .substring(0, 500);
+
+            log.info('PLAYER', `Updating voice status: ${statusText}`);
+
+            await this.manager.client.rest.put(`/channels/${this.voiceChannelId}/voice-status`, {
+                body: { status: statusText }
+            });
+            
+            this._lastStatusUpdate = now;
+            log.info('PLAYER', `Voice channel status updated successfully`);
+        } catch (error) {
+            log.error('PLAYER', `Failed to update voice channel status: ${error.message}`);
+        }
+    }
+
+    async _clearVoiceChannelStatus() {
+        if (!this.voiceChannelStatus.enabled) return;
+
+        try {
+            await this.manager.client.rest.put(`/channels/${this.voiceChannelId}/voice-status`, {
+                body: { status: "" }
+            });
+            log.info('PLAYER', 'Cleared voice channel status');
+        } catch (error) {
+            log.error('PLAYER', `Failed to clear voice channel status: ${error.message}`);
         }
-        this._prefetchedTrack = null;
     }
 
     async _handleAutoplay(lastTrack) {
@@ -440,6 +502,7 @@ class Player extends EventEmitter {
 
         this.audioPlayer.stop(true);
         log.info('PLAYER', `Paused playback at ${Math.floor(this._positionMs / 1000)}s (Reason: User Request)`);
+        this._clearVoiceChannelStatus();
 
         return true;
     }
@@ -466,6 +529,7 @@ class Player extends EventEmitter {
                 this._positionTimestamp = Date.now();
 
                 this._prefetchNext();
+                this._updateVoiceChannelStatus(track, true);
             } catch (error) {
                 log.error('PLAYER', `Resume failed: ${error.message}`);
                 this._paused = false;
@@ -479,6 +543,7 @@ class Player extends EventEmitter {
             this.audioPlayer.unpause();
             this._paused = false;
             this._positionTimestamp = Date.now();
+            this._updateVoiceChannelStatus(this.queue.current, true);
         }
 
         return true;
@@ -551,6 +616,7 @@ class Player extends EventEmitter {
         this.queue.setCurrent(null);
         
         log.info('PLAYER', 'Stopped playback and cleared queue');
+        this._clearVoiceChannelStatus();
         
         return true;
     }
@@ -779,6 +845,7 @@ class Player extends EventEmitter {
         this.queue.clear();
         this.queue.setCurrent(null);
 
+        this._clearVoiceChannelStatus();
         this.emit('destroy');
         this.removeAllListeners();
     }
@@ -802,4 +869,4 @@ class Player extends EventEmitter {
     }
 }
 
-module.exports = Player;
+module.exports = Player;

package/src/discord/Stream.js

@@ -21,8 +21,6 @@ class StreamController {
         this.resource = null;
         this.destroyed = false;
         this.startTime = null;
-        this.bytesReceived = 0;
-        this.bytesSent = 0;
         this.ytdlpError = '';
         this.ffmpegError = '';
         
@@ -71,15 +69,16 @@ class StreamController {
 
         log.info('STREAM', `Creating stream for ${videoId} (${source})`);
         
-        // Log Filter Chain
-        const filterNames = Object.keys(this.filters).filter(k => k !== 'start' && k !== '_trigger');
+        // Log Filter Chain Trace (No data impact)
+        const filterNames = Object.keys(this.filters).filter(k => k !== 'start' && k !== '_trigger' && k !== 'volume');
         if (filterNames.length > 0) {
             const chain = filterNames.map(name => {
                 const val = this.filters[name];
-                const displayVal = typeof val === 'object' ? JSON.stringify(val) : val;
-                return `[${name} (${displayVal})]`;
-            }).join(' -> ');
-            log.debug('STREAM', `Filter Chain: ${chain}`);
+                let displayVal = typeof val === 'object' ? JSON.stringify(val) : val;
+                if (displayVal === true || displayVal === 'true') displayVal = 'ON';
+                return `[${name.toUpperCase()} (${displayVal})]`;
+            }).join(' ➔ ');
+            log.info('STREAM', `Filter Chain: ${chain}`);
         }
 
         let url;
@@ -112,7 +111,6 @@ class StreamController {
 
         if (isLive) {
             ytdlpArgs.push('--no-live-from-start');
-            log.info('STREAM', `Live stream detected, using live-compatible format`);
         } else if (isYouTube) {
             ytdlpArgs.push('--extractor-args', 'youtube:player_client=web_creator');
         }
@@ -143,29 +141,8 @@ class StreamController {
         
         this.metrics.spawn = Date.now() - spawnStart;
 
-        const { pipeline } = require('stream');
-
-        this._firstDataTime = null;
-        
-        this.ytdlp.stdout.on('data', (chunk) => {
-            this.bytesReceived += chunk.length;
-        });
-
-        this.ffmpeg.stdout.on('data', (chunk) => {
-            if (!this._firstDataTime) {
-                this._firstDataTime = Date.now() - this.startTime;
-                this.metrics.firstByte = Date.now() - (startTimestamp + this.metrics.metadata + this.metrics.spawn);
-            }
-            this.bytesSent += chunk.length;
-        });
-
-        pipeline(this.ytdlp.stdout, this.ffmpeg.stdin, (err) => {
-            if (err && !this.destroyed) {
-                if (err.code !== 'ERR_STREAM_PREMATURE_CLOSE' && err.code !== 'EPIPE') {
-                    log.debug('STREAM', `Pipeline error: ${err.message}`);
-                }
-            }
-        });
+        // Direct pipe for stability
+        this.ytdlp.stdout.pipe(this.ffmpeg.stdin);
 
         this.ytdlp.stderr.on('data', (data) => {
             if (this.destroyed) return;
@@ -190,42 +167,9 @@ class StreamController {
         this.ytdlp.on('close', (code) => {
             if (code !== 0 && code !== null && !this.destroyed) {
                 log.error('STREAM', `yt-dlp failed (code: ${code}) for ${videoId}`);
-                if (this.ytdlpError) {
-                    log.error('STREAM', `yt-dlp stderr: ${this.ytdlpError.slice(-500)}`);
-                }
             }
             if (this.ffmpeg && !this.ffmpeg.killed && this.ffmpeg.stdin) {
-                this.ffmpeg.stdin.end();
-            }
-        });
-
-        this.ytdlp.on('error', (error) => {
-            if (error.code !== 'EPIPE' && !this.destroyed) {
-                log.error('STREAM', `yt-dlp spawn error: ${error.message}`);
-            }
-        });
-
-        this.ffmpeg.on('error', (error) => {
-            if (error.code !== 'EPIPE' && !this.destroyed) {
-                log.error('STREAM', `ffmpeg spawn error: ${error.message}`);
-            }
-        });
-
-        this.ytdlp.stdout.on('error', (error) => {
-            if (error.code !== 'EPIPE' && !this.destroyed) {
-                log.debug('STREAM', `yt-dlp stdout error: ${error.message}`);
-            }
-        });
-
-        this.ffmpeg.stdin.on('error', (error) => {
-            if (error.code !== 'EPIPE' && !this.destroyed) {
-                log.debug('STREAM', `ffmpeg stdin error: ${error.message}`);
-            }
-        });
-
-        this.ffmpeg.stdout.on('error', (error) => {
-            if (error.code !== 'EPIPE' && !this.destroyed) {
-                log.debug('STREAM', `ffmpeg stdout error: ${error.message}`);
+                try { this.ffmpeg.stdin.end(); } catch(e) {}
             }
         });
 
@@ -239,7 +183,7 @@ class StreamController {
         const elapsed = Date.now() - startTimestamp;
         this.metrics.total = elapsed;
         
-        log.info('STREAM', `Ready ${elapsed}ms | Metrics: [Metadata: ${this.metrics.metadata}ms | Spawn: ${this.metrics.spawn}ms | FirstByte: ${this.metrics.firstByte}ms] | Buffered: ${this.bytesSent}b`);
+        log.info('STREAM', `Ready ${elapsed}ms | Metrics: [Metadata: ${this.metrics.metadata}ms | Spawn: ${this.metrics.spawn}ms | FirstByte: ${this.metrics.firstByte}ms]`);
 
         return this.resource;
     }
@@ -248,40 +192,40 @@ class StreamController {
         return new Promise((resolve, reject) => {
             const timeoutMs = isLive ? 30000 : 15000;
             const timeout = setTimeout(() => {
-                log.warn('STREAM', `Timeout waiting for data, proceeding anyway (received: ${this.bytesSent}, isLive: ${isLive})`);
+                log.warn('STREAM', `Timeout waiting for data, proceeding anyway`);
                 resolve();
             }, timeoutMs);
 
             let resolved = false;
 
-            const checkInterval = setInterval(() => {
-                if (resolved) {
-                    clearInterval(checkInterval);
-                    return;
-                }
-                if (this.bytesSent > 0) {
+            // USE READABLE EVENT: Zero-consumption way to detect data
+            const onReadable = () => {
+                if (!resolved) {
                     resolved = true;
                     clearTimeout(timeout);
-                    clearInterval(checkInterval);
+                    this.metrics.firstByte = Date.now() - (this.startTime + this.metrics.metadata + this.metrics.spawn);
+                    this.ffmpeg.stdout.removeListener('readable', onReadable);
                     resolve();
                 }
-            }, 50);
+            };
+
+            this.ffmpeg.stdout.on('readable', onReadable);
 
             this.ffmpeg.on('close', () => {
                 if (!resolved) {
                     resolved = true;
                     clearTimeout(timeout);
-                    clearInterval(checkInterval);
-                    reject(new Error(`ffmpeg closed before producing data. ffmpeg stderr: ${this.ffmpegError.slice(-200) || 'none'} | yt-dlp stderr: ${this.ytdlpError.slice(-200) || 'none'}`));
+                    this.ffmpeg.stdout.removeListener('readable', onReadable);
+                    reject(new Error(`ffmpeg closed before producing data. yt-dlp stderr: ${this.ytdlpError.slice(-200) || 'none'}`));
                 }
             });
 
             this.ytdlp.on('close', (code) => {
-                if (!resolved && code !== 0) {
+                if (!resolved && code !== 0 && code !== null) {
                     resolved = true;
                     clearTimeout(timeout);
-                    clearInterval(checkInterval);
-                    reject(new Error(`yt-dlp failed with code ${code}. stderr: ${this.ytdlpError.slice(-200) || 'none'}`));
+                    this.ffmpeg.stdout.removeListener('readable', onReadable);
+                    reject(new Error(`yt-dlp failed with code ${code}`));
                 }
             });
         });
@@ -292,7 +236,7 @@ class StreamController {
         this.destroyed = true;
 
         const elapsed = this.startTime ? Date.now() - this.startTime : 0;
-        log.info('STREAM', `Destroying stream | Duration: ${elapsed}ms | Data Out: ${(this.bytesSent / 1024 / 1024).toFixed(2)} MB`);
+        log.info('STREAM', `Destroying stream | Duration: ${Math.floor(elapsed / 1000)}s`);
 
         try {
             if (this.ytdlp && this.ffmpeg) {