streamify-audio 2.3.1 → 2.3.2

package/docs/quick-start.md

@@ -1,92 +0,0 @@
-# Quick Start
-
-## Installation
-
-```bash
-npm install streamify-audio @discordjs/voice @discordjs/opus
-```
-
-## Requirements
-
-- Node.js 18+
-- [yt-dlp](https://github.com/yt-dlp/yt-dlp) — `pip install yt-dlp`
-- [ffmpeg](https://ffmpeg.org/) — `apt install ffmpeg`
-
-## Discord Bot (5 minutes)
-
-```javascript
-const { Client, GatewayIntentBits } = require('discord.js');
-const Streamify = require('streamify-audio');
-
-const client = new Client({
-    intents: [
-        GatewayIntentBits.Guilds,
-        GatewayIntentBits.GuildVoiceStates,
-        GatewayIntentBits.GuildMessages,
-        GatewayIntentBits.MessageContent
-    ]
-});
-
-const manager = new Streamify.Manager(client, {
-    ytdlpPath: '/usr/local/bin/yt-dlp',
-    ffmpegPath: '/usr/bin/ffmpeg'
-});
-
-client.on('messageCreate', async (message) => {
-    if (!message.content.startsWith('!')) return;
-
-    const [cmd, ...args] = message.content.slice(1).split(' ');
-    const query = args.join(' ');
-
-    if (cmd === 'play') {
-        const vc = message.member.voice.channel;
-        if (!vc) return message.reply('Join a voice channel first!');
-
-        const result = await manager.search(query);
-        if (!result.tracks.length) return message.reply('No results found.');
-
-        const player = await manager.create(message.guild.id, vc.id, message.channel.id);
-
-        player.on('trackStart', (track) => {
-            message.channel.send(`Now playing: **${track.title}**`);
-        });
-
-        await player.play(result.tracks[0]);
-    }
-
-    if (cmd === 'skip') {
-        const player = manager.get(message.guild.id);
-        if (player) await player.skip();
-    }
-
-    if (cmd === 'stop') {
-        const player = manager.get(message.guild.id);
-        if (player) player.destroy();
-    }
-});
-
-client.login(process.env.TOKEN);
-```
-
-## HTTP Server (3 minutes)
-
-```javascript
-const Streamify = require('streamify-audio');
-
-const streamify = new Streamify({ port: 8787 });
-await streamify.start();
-
-// Search
-const results = await streamify.youtube.search('never gonna give you up');
-console.log(results.tracks[0].title);
-
-// Get stream URL
-const url = streamify.youtube.getStreamUrl(results.tracks[0].id);
-// http://127.0.0.1:8787/youtube/stream/dQw4w9WgXcQ
-```
-
-## Next Steps
-
-- [Configuration](./configuration.md) — Add Spotify, cookies, filters
-- [Discord Player](./discord/manager.md) — Full player documentation
-- [HTTP Server](./http/server.md) — API endpoints

package/docs/sources.md

@@ -1,189 +0,0 @@
-# Sources
-
-Streamify supports YouTube, Spotify, SoundCloud, Twitch, Mixcloud, Bandcamp, Local Files, and Direct URLs.
-
-## Supported Features
-
-| Source | Search | Track URL | Playlist | Album |
-|--------|:------:|:---------:|:--------:|:-----:|
-| YouTube | ✅ | ✅ | ✅ | — |
-| Spotify | ✅ | ✅ | ✅ | ✅ |
-| SoundCloud | ✅ | ✅ | ❌ | — |
-| Twitch | ✅ | ✅ | — | — |
-| Mixcloud | ✅ | ✅ | — | — |
-| Bandcamp | ✅ | ✅ | — | ✅ |
-| Direct URL | ✅ | ✅ | — | — |
-| Local File | ✅ | ✅ | — | — |
-
-## YouTube
-
-YouTube is the primary source. All audio is streamed directly from YouTube.
-
-```javascript
-// Search
-const result = await manager.search('never gonna give you up');
-const result = await manager.search(query, { source: 'youtube' });
-
-// Direct URL
-const result = await manager.resolve('https://youtube.com/watch?v=dQw4w9WgXcQ');
-const result = await manager.resolve('https://youtu.be/dQw4w9WgXcQ');
-const result = await manager.resolve('https://music.youtube.com/watch?v=dQw4w9WgXcQ');
-
-// Playlist
-const result = await manager.loadPlaylist('https://youtube.com/playlist?list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf');
-```
-
-### Supported URL Formats
-
-- `youtube.com/watch?v=VIDEO_ID`
-- `youtu.be/VIDEO_ID`
-- `youtube.com/shorts/VIDEO_ID`
-- `music.youtube.com/watch?v=VIDEO_ID`
-- `youtube.com/playlist?list=PLAYLIST_ID`
-
-### Cookies
-
-For age-restricted or region-locked videos, provide YouTube cookies:
-
-```javascript
-const manager = new Streamify.Manager(client, {
-    cookiesPath: './cookies.txt'
-});
-```
-
-See [Configuration](./configuration.md#youtube-cookies) for setup instructions.
-
-## Spotify
-
-Spotify tracks are resolved to YouTube for playback. Requires API credentials.
-
-```javascript
-const manager = new Streamify.Manager(client, {
-    spotify: {
-        clientId: process.env.SPOTIFY_CLIENT_ID,
-        clientSecret: process.env.SPOTIFY_CLIENT_SECRET
-    }
-});
-```
-
-```javascript
-// Search
-const result = await manager.search('never gonna give you up', { source: 'spotify' });
-
-// Direct URL
-const result = await manager.resolve('https://open.spotify.com/track/4PTG3Z6ehGkBFwjybzWkR8');
-
-// Playlist
-const result = await manager.loadPlaylist('https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M');
-
-// Album
-const result = await manager.loadPlaylist('https://open.spotify.com/album/4LH4d3cOWNNsVw41Gqt2kv');
-```
-
-### Supported URL Formats
-
-- `open.spotify.com/track/TRACK_ID`
-- `open.spotify.com/playlist/PLAYLIST_ID`
-- `open.spotify.com/album/ALBUM_ID`
-- `spotify:track:TRACK_ID`
-
-### How Resolution Works
-
-1. Fetch track metadata from Spotify API
-2. Search YouTube for `{artist} - {title}`
-3. Use the first result for playback
-
-The resolved YouTube ID is cached for 5 minutes.
-
-## SoundCloud
-
-SoundCloud tracks are streamed via yt-dlp.
-
-```javascript
-// Search
-const result = await manager.search('never gonna give you up', { source: 'soundcloud' });
-
-// Direct URL
-const result = await manager.resolve('https://soundcloud.com/rick-astley-official/never-gonna-give-you-up');
-```
-
-### Supported URL Formats
-
-- `soundcloud.com/USER/TRACK`
-
-## Twitch & Mixcloud
-
-Streaming support for live content and DJ sets.
-
-```javascript
-// Twitch Live
-await manager.resolve('https://twitch.tv/monstercat');
-
-// Mixcloud Sets
-await manager.resolve('https://www.mixcloud.com/spinninrecords/spinnin-sessions-550/');
-```
-
-## Bandcamp
-
-Support for high-quality independent music.
-
-```javascript
-await manager.resolve('https://monstercatmedia.bandcamp.com/track/the-governor');
-```
-
-## Direct URLs (HTTP)
-
-Play raw audio files from any public URL.
-
-```javascript
-await manager.resolve('https://example.com/audio.mp3');
-await manager.resolve('https://cdn.discordapp.com/attachments/.../music.ogg');
-```
-
-## Local Files
-
-Play files directly from the host system.
-
-```javascript
-// Absolute path
-await manager.resolve('/home/user/music/track.mp3');
-
-// Relative path
-await manager.resolve('./assets/sound-effect.wav');
-
-// File URI
-await manager.resolve('file:///var/lib/music/song.flac');
-```
-
-## Auto-Detection
-
-The `resolve()` method auto-detects the source from URLs:
-
-```javascript
-// All of these work
-await manager.resolve('https://youtube.com/watch?v=dQw4w9WgXcQ');
-await manager.resolve('https://open.spotify.com/track/4PTG3Z6ehGkBFwjybzWkR8');
-await manager.resolve('https://soundcloud.com/rick-astley-official/never-gonna-give-you-up');
-await manager.resolve('https://twitch.tv/some-channel');
-await manager.resolve('/path/to/local/file.mp3');
-```
-
-## Track Object
-
-All sources return the same track structure:
-
-```javascript
-{
-    id: 'dQw4w9WgXcQ',
-    title: 'Rick Astley - Never Gonna Give You Up',
-    author: 'Rick Astley',
-    duration: 213,           // seconds
-    thumbnail: 'https://...',
-    uri: 'https://...',      // Original URL
-    source: 'youtube',       // youtube, spotify, soundcloud
-
-    // Spotify only
-    album: 'Whenever You Need Somebody',
-    _resolvedId: 'dQw4w9WgXcQ'  // YouTube ID
-}
-```

package/docs/sponsorblock.md

@@ -1,95 +0,0 @@
-# Sponsorblock
-
-Streamify integrates with [SponsorBlock](https://sponsor.ajay.app/) to automatically skip sponsored segments in YouTube videos.
-
-## Configuration
-
-```javascript
-const manager = new Streamify.Manager(client, {
-    sponsorblock: {
-        enabled: true,
-        categories: ['sponsor', 'selfpromo', 'intro', 'outro']
-    }
-});
-```
-
-## Categories
-
-| Category | Description |
-|----------|-------------|
-| `sponsor` | Paid promotion, sponsored content |
-| `selfpromo` | Self-promotion, merchandise, Patreon |
-| `intro` | Intro animation, opening sequence |
-| `outro` | Outro, end cards, credits |
-| `preview` | Preview of other videos |
-| `filler` | Tangents, jokes, off-topic |
-| `interaction` | Subscribe reminders, like requests |
-| `music_offtopic` | Non-music sections in music videos |
-
-## Default Categories
-
-By default, Streamify skips:
-- `sponsor`
-- `selfpromo`
-
-```javascript
-// Default behavior
-sponsorblock: {
-    enabled: true,
-    categories: ['sponsor', 'selfpromo']
-}
-```
-
-## Skip Everything
-
-```javascript
-sponsorblock: {
-    enabled: true,
-    categories: [
-        'sponsor',
-        'selfpromo',
-        'intro',
-        'outro',
-        'preview',
-        'filler',
-        'interaction',
-        'music_offtopic'
-    ]
-}
-```
-
-## Music Videos
-
-For music, you might want:
-
-```javascript
-sponsorblock: {
-    enabled: true,
-    categories: ['sponsor', 'selfpromo', 'intro', 'outro', 'music_offtopic']
-}
-```
-
-## Disabling
-
-```javascript
-sponsorblock: {
-    enabled: false
-}
-```
-
-Or omit the `sponsorblock` config entirely.
-
-## How It Works
-
-1. When a YouTube stream starts, yt-dlp queries the SponsorBlock API
-2. Segment timestamps are fetched for the video
-3. yt-dlp removes those segments during download
-4. Audio plays seamlessly without the sponsored content
-
-## Notes
-
-- Only works with YouTube (Spotify/SoundCloud unaffected)
-- Segments are crowdsourced and may not exist for all videos
-- Popular videos have more complete segment data
-- Occasionally segments may be slightly inaccurate
-- No additional latency - segments are fetched during stream initialization

package/tests/cache.test.js

@@ -1,234 +0,0 @@
-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);
-        });
-    });
-});

package/tests/config.test.js

@@ -1,44 +0,0 @@
-const test = require('node:test');
-const assert = require('node:assert');
-const { loadConfig, defaults } = require('../src/config');
-const fs = require('fs');
-const path = require('path');
-
-test('Config: loading', async (t) => {
-    await t.test('should load default values', () => {
-        const config = loadConfig({ ytdlpPath: 'yt-dlp', ffmpegPath: 'ffmpeg' }); // Provide paths to avoid check failure
-        assert.strictEqual(config.port, defaults.port);
-        assert.strictEqual(config.audio.bitrate, '128k');
-    });
-
-    await t.test('should respect environment variables', () => {
-        process.env.PORT = '9999';
-        process.env.SPOTIFY_CLIENT_ID = 'test-id';
-        
-        const config = loadConfig({ ytdlpPath: 'yt-dlp', ffmpegPath: 'ffmpeg' });
-        assert.strictEqual(config.port, 9999);
-        assert.strictEqual(config.spotify.clientId, 'test-id');
-        
-        // Cleanup
-        delete process.env.PORT;
-        delete process.env.SPOTIFY_CLIENT_ID;
-    });
-
-    await t.test('should load from custom config file', () => {
-        const configPath = path.resolve(__dirname, 'temp-config.json');
-        const customConfig = {
-            port: 1234,
-            audio: { bitrate: '320k' }
-        };
-        
-        fs.writeFileSync(configPath, JSON.stringify(customConfig));
-        
-        try {
-            const config = loadConfig({ configPath, ytdlpPath: 'yt-dlp', ffmpegPath: 'ffmpeg' });
-            assert.strictEqual(config.port, 1234);
-            assert.strictEqual(config.audio.bitrate, '320k');
-        } finally {
-            if (fs.existsSync(configPath)) fs.unlinkSync(configPath);
-        }
-    });
-});