streamify-audio 2.3.0 → 2.3.2

package/index.d.ts

@@ -203,6 +203,15 @@ declare module 'streamify-audio' {
             enabled?: boolean;
             maxTracks?: number;
         };
+        stream?: {
+            dataTimeout?: number;
+            pipeDataTimeout?: number;
+            liveDataTimeout?: number;
+            extractTimeout?: number;
+            urlCacheTTL?: number;
+            bufferSize?: string;
+            maxRetries?: number;
+        };
     }
 
     export interface ManagerStats {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamify-audio",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "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

@@ -41,10 +41,16 @@ const defaults = {
     },
     stream: {
         dataTimeout: 8000,
+        pipeDataTimeout: 20000,
         liveDataTimeout: 15000,
+        extractTimeout: 30000,
         urlCacheTTL: 1800,
         bufferSize: '1M',
         maxRetries: 2
+    },
+    sponsorblock: {
+        enabled: false,
+        categories: ['sponsor', 'selfpromo']
     }
 };
 
@@ -119,6 +125,11 @@ function load(options = {}) {
             ...defaults.stream,
             ...fileConfig.stream,
             ...options.stream
+        },
+        sponsorblock: {
+            ...defaults.sponsorblock,
+            ...fileConfig.sponsorblock,
+            ...options.sponsorblock
         }
     };
 

package/src/discord/Manager.js

@@ -403,7 +403,7 @@ class Manager extends EventEmitter {
     }
 
     async _resolveSpotifyToYouTube(track) {
-        const videoId = await spotify.resolveToYouTube(track.id, this.config);
+        const videoId = await spotify.resolveToYouTube(track.id, this.config, track);
         return videoId;
     }
 

package/src/discord/Stream.js

@@ -95,7 +95,7 @@ class StreamController {
             log.info('STREAM', `Resolving Spotify track to YouTube: ${this.track.title}`);
             try {
                 const spotify = require('../providers/spotify');
-                videoId = await spotify.resolveToYouTube(this.track.id, this.config);
+                videoId = await spotify.resolveToYouTube(this.track.id, this.config, this.track);
                 this.track._resolvedId = videoId;
                 this.metrics.metadata = Date.now() - this.startTime;
             } catch (error) {
@@ -238,7 +238,7 @@ class StreamController {
                 ytdlpArgs.unshift('--cookies', this.config.cookiesPath);
             }
 
-            if (this.config.sponsorblock?.enabled !== false && isYouTube) {
+            if (this.config.sponsorblock?.enabled === true && isYouTube) {
                 const categories = this.config.sponsorblock?.categories || ['sponsor', 'selfpromo'];
                 ytdlpArgs.push('--sponsorblock-remove', categories.join(','));
             }
@@ -365,11 +365,9 @@ class StreamController {
             const url = `https://www.youtube.com/watch?v=${videoId}`;
             const args = [
                 '--get-url',
-                '-f', config.ytdlp.format,
+                '-f', 'bestaudio/best',
                 '--no-playlist',
-                '--no-check-certificates',
                 '--no-warnings',
-                '--no-cache-dir',
                 url
             ];
 
@@ -381,20 +379,16 @@ class StreamController {
                 args.unshift('--cookies', config.cookiesPath);
             }
 
-            if (config.sponsorblock?.enabled !== false && isYouTube) {
-                const categories = config.sponsorblock?.categories || ['sponsor', 'selfpromo'];
-                args.push('--sponsorblock-remove', categories.join(','));
-            }
-
             const env = { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH };
             const proc = spawn(config.ytdlpPath, args, { env });
 
             let stdout = '';
             let stderr = '';
+            const extractTimeout = config.stream?.extractTimeout || 30000;
             const timeout = setTimeout(() => {
                 proc.kill('SIGKILL');
                 reject(new Error('URL extraction timed out'));
-            }, 15000);
+            }, extractTimeout);
 
             proc.stdout.on('data', (data) => { stdout += data; });
             proc.stderr.on('data', (data) => { stderr += data; });
@@ -422,9 +416,12 @@ class StreamController {
         const ffmpeg = this.ffmpeg;
         const ytdlp = this.ytdlp;
         const isLive = this.track.isLive === true || this.track.duration === 0;
+        const isPipe = !!this.ytdlp;
         const timeoutMs = isLive
             ? (this.config.stream?.liveDataTimeout || 15000)
-            : (this.config.stream?.dataTimeout || 8000);
+            : isPipe
+                ? (this.config.stream?.pipeDataTimeout || 20000)
+                : (this.config.stream?.dataTimeout || 8000);
 
         return new Promise((resolve, reject) => {
             if (!ffmpeg) return resolve();

package/src/providers/spotify.js

@@ -104,14 +104,14 @@ async function getInfo(trackId, config) {
     };
 }
 
-async function resolveToYouTube(trackId, config) {
+async function resolveToYouTube(trackId, config, trackInfo = null) {
     const cached = youtubeIdCache.get(trackId);
     if (cached && Date.now() < cached.expires) {
         log.info('SPOTIFY', `Using cached YouTube ID: ${cached.videoId}`);
         return cached.videoId;
     }
 
-    const track = await getInfo(trackId, config);
+    const track = trackInfo || await getInfo(trackId, config);
     const searchQuery = `${track.author} - ${track.title}`;
     log.info('SPOTIFY', `Searching YouTube: "${searchQuery}"`);
 

package/docs/README.md

@@ -1,31 +0,0 @@
-# Streamify Documentation
-
-## Getting Started
-
-- [Quick Start](./quick-start.md) — Get up and running in 5 minutes
-- [Configuration](./configuration.md) — All configuration options
-
-## Discord Player Mode
-
-- [Manager](./discord/manager.md) — Create and manage players
-- [Player](./discord/player.md) — Playback control and state
-- [Queue](./discord/queue.md) — Queue management
-- [Events](./discord/events.md) — All player events
-
-## HTTP Server Mode
-
-- [Server Setup](./http/server.md) — Start the HTTP server
-- [Endpoints](./http/endpoints.md) — API reference
-
-## Features
-
-- [Filters](./filters.md) — Audio filters and presets
-- [Sources](./sources.md) — YouTube, Spotify, SoundCloud
-- [Automation](./automation.md) — Auto-pause, auto-leave, autoplay
-- [Sponsorblock](./sponsorblock.md) — Skip YouTube sponsors
-
-## Examples
-
-- [Basic Discord Bot](./examples/basic-bot.md)
-- [Advanced Bot with Queue](./examples/advanced-bot.md)
-- [HTTP Server with Lavalink](./examples/lavalink.md)

package/docs/automation.md

@@ -1,186 +0,0 @@
-# Automation
-
-Streamify includes built-in automation features for common scenarios.
-
-## Auto-Pause
-
-Automatically pauses playback when users leave the voice channel and resumes when they return.
-
-### Configuration
-
-```javascript
-const manager = new Streamify.Manager(client, {
-    autoPause: {
-        enabled: true,
-        minUsers: 1    // Pause when users drop below this
-    }
-});
-```
-
-### Behavior
-
-1. User count drops below `minUsers`
-2. Playback pauses immediately
-3. Stream is destroyed (saves resources)
-4. Position is saved
-5. When users rejoin and count reaches `minUsers`:
-6. Stream recreates with seek
-7. Playback resumes
-
-### Events
-
-```javascript
-player.on('autoPause', (userCount) => {
-    channel.send(`Paused (${userCount} users in channel)`);
-});
-
-player.on('autoResume', (userCount) => {
-    channel.send(`Resumed (${userCount} users now)`);
-});
-```
-
-### Runtime Toggle
-
-```javascript
-player.setAutoPause(false);  // Disable
-player.setAutoPause(true);   // Enable
-```
-
-## Auto-Leave
-
-Automatically leaves the voice channel after a period of inactivity.
-
-### Configuration
-
-```javascript
-const manager = new Streamify.Manager(client, {
-    autoLeave: {
-        enabled: true,
-        emptyDelay: 30000,         // Leave 30s after channel empty
-        inactivityTimeout: 300000  // Leave after 5min of not playing
-    }
-});
-```
-
-### Behavior
-
-**Empty Channel:**
-1. All users leave
-2. 30 second countdown starts
-3. If no one rejoins, player destroys
-
-**Inactivity:**
-1. Queue ends, nothing playing
-2. 5 minute countdown starts
-3. If nothing plays, player destroys
-
-### Events
-
-```javascript
-player.on('channelEmpty', () => {
-    channel.send('Everyone left. Leaving in 30 seconds...');
-});
-
-player.on('destroy', () => {
-    channel.send('Disconnected due to inactivity.');
-});
-```
-
-## Autoplay
-
-Automatically plays related tracks when the queue ends.
-
-### Configuration
-
-```javascript
-const manager = new Streamify.Manager(client, {
-    autoplay: {
-        enabled: false,   // Off by default
-        maxTracks: 5      // How many related tracks to fetch
-    }
-});
-```
-
-### Behavior
-
-1. Queue ends (last track finishes)
-2. Fetch related tracks from YouTube Mix or Spotify Recommendations
-3. Add to queue and start playing
-4. Repeat when those tracks end
-
-### Events
-
-```javascript
-player.on('autoplayStart', (lastTrack) => {
-    console.log(`Finding tracks like: ${lastTrack.title}`);
-});
-
-player.on('autoplayAdd', (tracks) => {
-    channel.send(`Autoplay added ${tracks.length} tracks`);
-});
-```
-
-### Runtime Toggle
-
-```javascript
-player.setAutoplay(true);   // Enable
-player.setAutoplay(false);  // Disable
-```
-
-### Track Identification
-
-Autoplay tracks are marked:
-
-```javascript
-player.on('trackStart', (track) => {
-    if (track.isAutoplay) {
-        channel.send(`Autoplay: **${track.title}**`);
-    } else {
-        channel.send(`Now playing: **${track.title}**`);
-    }
-});
-```
-
-## Combining Features
-
-All automation features work together:
-
-```javascript
-const manager = new Streamify.Manager(client, {
-    autoPause: {
-        enabled: true,
-        minUsers: 1
-    },
-    autoLeave: {
-        enabled: true,
-        emptyDelay: 30000,
-        inactivityTimeout: 300000
-    },
-    autoplay: {
-        enabled: true,
-        maxTracks: 5
-    }
-});
-```
-
-**Scenario: User leaves during playback**
-1. `autoPause` triggers → pauses playback
-2. `autoLeave` starts 30s countdown
-3. User rejoins within 30s
-4. `autoResume` triggers → playback continues
-5. Countdown cancelled
-
-**Scenario: Queue ends**
-1. `autoplay` fetches related tracks
-2. Playback continues with recommendations
-3. If autoplay disabled, `autoLeave` inactivity timeout starts
-
-## Disabling All Automation
-
-```javascript
-const manager = new Streamify.Manager(client, {
-    autoPause: { enabled: false },
-    autoLeave: { enabled: false },
-    autoplay: { enabled: false }
-});
-```

package/docs/configuration.md

@@ -1,198 +0,0 @@
-# Configuration
-
-## Discord Player Mode
-
-```javascript
-const manager = new Streamify.Manager(client, {
-    // Paths (required)
-    ytdlpPath: '/usr/local/bin/yt-dlp',
-    ffmpegPath: '/usr/bin/ffmpeg',
-
-    // YouTube cookies (optional)
-    cookiesPath: './cookies.txt',
-
-    // Providers (optional - all enabled by default)
-    providers: {
-        youtube: { enabled: true },
-        spotify: { enabled: true },
-        soundcloud: { enabled: true }
-    },
-
-    // Spotify credentials (optional)
-    spotify: {
-        clientId: process.env.SPOTIFY_CLIENT_ID,
-        clientSecret: process.env.SPOTIFY_CLIENT_SECRET
-    },
-
-    // Audio settings
-    audio: {
-        bitrate: '128k',      // Audio bitrate
-        format: 'opus',       // opus, mp3, aac
-        vbr: true,            // Enable Variable Bitrate (Opus only)
-        compressionLevel: 10, // Opus compression level (0-10)
-        application: 'audio'  // Opus application (audio, voip, lowdelay)
-    },
-
-    // yt-dlp settings
-    ytdlp: {
-        format: 'bestaudio/best', // Custom yt-dlp format string
-        additionalArgs: []        // Extra arguments for yt-dlp (e.g. proxy)
-    },
-
-    // Defaults
-    defaultVolume: 80,        // 0-200
-    maxPreviousTracks: 25,    // History size
-
-    // Sponsorblock
-    sponsorblock: {
-        enabled: true,
-        categories: ['sponsor', 'selfpromo', 'intro', 'outro']
-    },
-
-    // Auto-leave
-    autoLeave: {
-        enabled: true,
-        emptyDelay: 30000,        // Leave 30s after channel empty
-        inactivityTimeout: 300000 // Leave after 5min idle
-    },
-
-    // Auto-pause
-    autoPause: {
-        enabled: true,
-        minUsers: 1               // Pause when users drop below this
-    },
-
-    // Autoplay
-    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
-const streamify = new Streamify({
-    // Server
-    port: 8787,
-    host: '0.0.0.0',
-
-    // Paths
-    ytdlpPath: '/usr/local/bin/yt-dlp',
-    ffmpegPath: '/usr/bin/ffmpeg',
-
-    // YouTube cookies
-    cookiesPath: './cookies.txt',
-    // Or direct string:
-    cookies: '# Netscape HTTP Cookie File\n...',
-
-    // Providers (optional - all enabled by default)
-    providers: {
-        youtube: { enabled: true },
-        spotify: { enabled: true },
-        soundcloud: { enabled: true }
-    },
-
-    // Spotify
-    spotify: {
-        clientId: 'xxx',
-        clientSecret: 'xxx'
-    },
-
-    // Audio
-    audio: {
-        bitrate: '128k',
-        format: 'opus',
-        vbr: true,
-        compressionLevel: 10,
-        application: 'audio'
-    },
-
-    // yt-dlp
-    ytdlp: {
-        format: 'bestaudio/best',
-        additionalArgs: []
-    },
-
-    // Logging
-    logLevel: 'info',    // none, error, warn, info, debug
-    silent: false,
-    colors: true
-});
-```
-
-## Environment Variables
-
-| Variable | Description |
-|----------|-------------|
-| `SPOTIFY_CLIENT_ID` | Spotify API client ID |
-| `SPOTIFY_CLIENT_SECRET` | Spotify API client secret |
-| `YTDLP_PATH` | Path to yt-dlp binary |
-| `FFMPEG_PATH` | Path to ffmpeg binary |
-| `COOKIES_PATH` | Path to YouTube cookies file |
-| `PORT` | HTTP server port |
-
-## YouTube Cookies
-
-For age-restricted or region-locked videos:
-
-1. Install browser extension "Get cookies.txt"
-2. Visit youtube.com while logged in
-3. Export cookies in Netscape format
-4. Save as `cookies.txt`
-
-```javascript
-// File path
-cookiesPath: './cookies.txt'
-
-// Or direct string
-cookies: `# Netscape HTTP Cookie File
-.youtube.com	TRUE	/	TRUE	0	COOKIE_NAME	COOKIE_VALUE`
-```
-
-## Spotify Setup
-
-1. Go to [Spotify Developer Dashboard](https://developer.spotify.com/dashboard)
-2. Create an app
-3. Copy Client ID and Client Secret
-
-```javascript
-spotify: {
-    clientId: process.env.SPOTIFY_CLIENT_ID,
-    clientSecret: process.env.SPOTIFY_CLIENT_SECRET
-}
-```
-
-Spotify tracks are resolved to YouTube for playback.
-
-## Providers
-
-Enable or disable individual providers:
-
-```javascript
-providers: {
-    youtube: { enabled: true },
-    spotify: { enabled: true },
-    soundcloud: { enabled: false }  // Disabled
-}
-```
-
-All providers are enabled by default. When a disabled provider is accessed, an error is thrown:
-
-```
-Error: SoundCloud provider is disabled
-```
-
-This is useful if you only want to support specific platforms.