streamify-audio 2.2.7 → 2.2.9

package/README.md

@@ -229,12 +229,21 @@ const manager = new Streamify.Manager(client, {
 
 ### Search with Filters
 
-Filter for live streams or sort results by popularity/date.
+Filter for live streams, sort results, or filter by artist.
 
 ```javascript
 const results = await manager.search('lofi hip hop', {
-    type: 'live',
-    sort: 'popularity'
+    source: 'youtube',   // youtube, spotify, soundcloud
+    type: 'live',        // video, live, playlist
+    sort: 'popularity',  // relevance, popular, latest
+    limit: 10
+});
+
+// Artist search - filters results to only include tracks by that artist
+const artistTracks = await manager.search('Drake', {
+    source: 'spotify',
+    artist: 'Drake',     // filters results to tracks BY this artist
+    limit: 5
 });
 ```
 

package/docs/discord/manager.md

@@ -76,6 +76,7 @@ Searches for tracks.
     - `limit` (number) - Number of results (default: 10)
     - `type` (string) - `video`, `live`, or `all` (YouTube only)
     - `sort` (string) - `relevance`, `popularity`, `date`, or `rating` (YouTube only)
+    - `artist` (string) - Filter results to only include tracks by this artist
 
 **Example:**
 
@@ -85,6 +86,13 @@ const result = await manager.search('lofi hip hop', {
     type: 'live',
     sort: 'popularity'
 });
+
+// Artist search - filters results to tracks BY the artist
+const artistTracks = await manager.search('Drake', {
+    source: 'spotify',
+    artist: 'Drake',
+    limit: 5
+});
 ```
 
 // Result

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamify-audio",
-  "version": "2.2.7",
+  "version": "2.2.9",
   "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/discord/Manager.js

@@ -261,7 +261,7 @@ class Manager extends EventEmitter {
                     if (!this.config.spotify?.clientId) {
                         throw new Error('Spotify credentials not configured');
                     }
-                    result = await spotify.search(query, limit, this.config);
+                    result = await spotify.search(query, limit, this.config, options);
                     break;
 
                 case 'soundcloud':
@@ -269,7 +269,7 @@ class Manager extends EventEmitter {
                     if (!this._isProviderEnabled('soundcloud')) {
                         throw new Error('SoundCloud provider is disabled');
                     }
-                    result = await soundcloud.search(query, limit, this.config);
+                    result = await soundcloud.search(query, limit, this.config, options);
                     break;
 
                 case 'twitch':

package/src/providers/bandcamp.js

@@ -33,6 +33,7 @@ async function getInfo(url, config) {
                     title: data.title,
                     duration: data.duration || 0,
                     author: data.uploader || data.artist,
+                    authorUrl: data.uploader_url || null,
                     thumbnail: data.thumbnail,
                     uri: data.webpage_url,
                     streamUrl: `/bandcamp/stream/${Buffer.from(url).toString('base64')}`,

package/src/providers/mixcloud.js

@@ -33,6 +33,7 @@ async function getInfo(url, config) {
                     title: data.title,
                     duration: data.duration || 0,
                     author: data.uploader || data.user?.username,
+                    authorUrl: data.uploader_url || null,
                     thumbnail: data.thumbnail,
                     uri: data.webpage_url,
                     streamUrl: `/mixcloud/stream/${Buffer.from(url).toString('base64')}`,

package/src/providers/soundcloud.js

@@ -3,9 +3,11 @@ const { buildFfmpegArgs } = require('../filters/ffmpeg');
 const { registerStream, unregisterStream } = require('../utils/stream');
 const log = require('../utils/logger');
 
-async function search(query, limit, config) {
+async function search(query, limit, config, options = {}) {
     const startTime = Date.now();
-    log.info('SOUNDCLOUD', `Searching: "${query}" (limit: ${limit})`);
+    const artistFilter = options.artist ? options.artist.toLowerCase() : null;
+    const searchLimit = artistFilter ? Math.min(limit * 3, 25) : limit;
+    log.info('SOUNDCLOUD', `Searching: "${query}" (limit: ${limit}${artistFilter ? `, artist: ${options.artist}` : ''})`);
 
     return new Promise((resolve, reject) => {
         const args = [
@@ -13,7 +15,7 @@ async function search(query, limit, config) {
             '--flat-playlist',
             '--skip-download',
             '-J',
-            `scsearch${limit}:${query}`
+            `scsearch${searchLimit}:${query}`
         ];
 
         const proc = spawn(config.ytdlpPath, args, {
@@ -32,16 +34,27 @@ async function search(query, limit, config) {
             }
             try {
                 const data = JSON.parse(stdout);
-                const tracks = (data.entries || []).map(entry => ({
+                let tracks = (data.entries || []).map(entry => ({
                     id: entry.id,
                     title: entry.title,
                     duration: entry.duration,
                     author: entry.uploader,
+                    authorUrl: entry.uploader_url || null,
                     thumbnail: entry.thumbnails?.[0]?.url,
                     uri: entry.url || entry.webpage_url,
                     streamUrl: `/soundcloud/stream/${entry.id}`,
                     source: 'soundcloud'
                 }));
+
+                if (artistFilter) {
+                    tracks = tracks.filter(t => {
+                        const author = (t.author || '').toLowerCase();
+                        const title = (t.title || '').toLowerCase();
+                        return author.includes(artistFilter) || title.includes(artistFilter);
+                    }).slice(0, limit);
+                    log.info('SOUNDCLOUD', `Filtered to ${tracks.length} tracks by artist "${options.artist}"`);
+                }
+
                 const elapsed = Date.now() - startTime;
                 log.info('SOUNDCLOUD', `Found ${tracks.length} results (${elapsed}ms)`);
                 resolve({ tracks, source: 'soundcloud', searchTime: elapsed });
@@ -82,6 +95,7 @@ async function getInfo(trackId, config) {
                     title: data.title,
                     duration: data.duration,
                     author: data.uploader,
+                    authorUrl: data.uploader_url || null,
                     thumbnail: data.thumbnail,
                     uri: data.webpage_url,
                     streamUrl: `/soundcloud/stream/${data.id}`,

package/src/providers/spotify.js

@@ -52,16 +52,19 @@ async function spotifyApi(endpoint, config) {
     return response.json();
 }
 
-async function search(query, limit, config) {
+async function search(query, limit, config, options = {}) {
     const startTime = Date.now();
-    log.info('SPOTIFY', `Searching: "${query}" (limit: ${limit})`);
+    const artistFilter = options.artist ? options.artist.toLowerCase() : null;
+    const searchLimit = artistFilter ? Math.min(limit * 2, 50) : limit;
+    log.info('SPOTIFY', `Searching: "${query}" (limit: ${limit}${artistFilter ? `, artist: ${options.artist}` : ''})`);
 
-    const data = await spotifyApi(`/search?q=${encodeURIComponent(query)}&type=track&limit=${limit}`, config);
+    const data = await spotifyApi(`/search?q=${encodeURIComponent(query)}&type=track&limit=${searchLimit}`, config);
 
-    const tracks = (data.tracks?.items || []).map(track => ({
+    let tracks = (data.tracks?.items || []).map(track => ({
         id: track.id,
         title: track.name,
         author: track.artists.map(a => a.name).join(', '),
+        authorUrl: track.artists[0]?.external_urls?.spotify || null,
         album: track.album.name,
         duration: Math.floor(track.duration_ms / 1000),
         thumbnail: track.album.images?.[0]?.url,
@@ -70,6 +73,14 @@ async function search(query, limit, config) {
         source: 'spotify'
     }));
 
+    if (artistFilter) {
+        tracks = tracks.filter(t => {
+            const author = (t.author || '').toLowerCase();
+            return author.includes(artistFilter);
+        }).slice(0, limit);
+        log.info('SPOTIFY', `Filtered to ${tracks.length} tracks by artist "${options.artist}"`);
+    }
+
     const elapsed = Date.now() - startTime;
     log.info('SPOTIFY', `Found ${tracks.length} results (${elapsed}ms)`);
     return { tracks, source: 'spotify', searchTime: elapsed };
@@ -83,6 +94,7 @@ async function getInfo(trackId, config) {
         id: track.id,
         title: track.name,
         author: track.artists.map(a => a.name).join(', '),
+        authorUrl: track.artists[0]?.external_urls?.spotify || null,
         album: track.album.name,
         duration: Math.floor(track.duration_ms / 1000),
         thumbnail: track.album.images?.[0]?.url,
@@ -142,6 +154,7 @@ async function getPlaylist(playlistId, config) {
             id: item.track.id,
             title: item.track.name,
             author: item.track.artists.map(a => a.name).join(', '),
+            authorUrl: item.track.artists[0]?.external_urls?.spotify || null,
             album: item.track.album.name,
             duration: Math.floor(item.track.duration_ms / 1000),
             thumbnail: item.track.album.images?.[0]?.url,
@@ -171,6 +184,7 @@ async function getAlbum(albumId, config) {
         id: track.id,
         title: track.name,
         author: track.artists.map(a => a.name).join(', '),
+        authorUrl: track.artists[0]?.external_urls?.spotify || null,
         album: data.name,
         duration: Math.floor(track.duration_ms / 1000),
         thumbnail: data.images?.[0]?.url,
@@ -200,6 +214,7 @@ async function getRecommendations(trackId, limit, config) {
         id: track.id,
         title: track.name,
         author: track.artists.map(a => a.name).join(', '),
+        authorUrl: track.artists[0]?.external_urls?.spotify || null,
         album: track.album.name,
         duration: Math.floor(track.duration_ms / 1000),
         thumbnail: track.album.images?.[0]?.url,

package/src/providers/twitch.js

@@ -28,11 +28,14 @@ async function getInfo(url, config) {
             }
             try {
                 const data = JSON.parse(stdout);
+                const authorUrl = data.uploader_url || data.channel_url ||
+                    (data.channel ? `https://www.twitch.tv/${data.channel}` : null);
                 resolve({
                     id: data.id,
                     title: data.title,
                     duration: data.duration || 0,
                     author: data.uploader || data.channel,
+                    authorUrl,
                     thumbnail: data.thumbnail,
                     uri: data.webpage_url,
                     streamUrl: `/twitch/stream/${Buffer.from(url).toString('base64')}`,

package/src/providers/youtube.js

@@ -5,7 +5,9 @@ const log = require('../utils/logger');
 
 async function search(query, limit, config, options = {}) {
     const startTime = Date.now();
-    log.info('YOUTUBE', `Searching: "${query}" (limit: ${limit}, type: ${options.type || 'all'}, sort: ${options.sort || 'relevance'})`);
+    const artistFilter = options.artist ? options.artist.toLowerCase() : null;
+    const searchLimit = artistFilter ? Math.min(limit * 3, 25) : limit;
+    log.info('YOUTUBE', `Searching: "${query}" (limit: ${limit}, type: ${options.type || 'all'}, sort: ${options.sort || 'relevance'}${artistFilter ? `, artist: ${options.artist}` : ''})`);
 
     return new Promise((resolve, reject) => {
         const args = [
@@ -20,15 +22,13 @@ async function search(query, limit, config, options = {}) {
         }
 
         let searchQuery = query;
-        
-        // Handle sorting by modifying search query or using filters
+
         if (options.sort === 'views' || options.sort === 'popular') {
             searchQuery += ' most viewed';
         } else if (options.sort === 'date' || options.sort === 'latest') {
             searchQuery += ' new';
         }
 
-        // Handle type filtering
         if (options.type === 'live') {
             args.push('--match-filter', 'live_status = is_live');
         } else if (options.type === 'playlist') {
@@ -37,7 +37,7 @@ async function search(query, limit, config, options = {}) {
             args.push('--match-filter', 'live_status != is_live');
         }
 
-        args.push(`ytsearch${limit}:${searchQuery}`);
+        args.push(`ytsearch${searchLimit}:${searchQuery}`);
 
         const proc = spawn(config.ytdlpPath, args, {
             env: { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH }
@@ -59,7 +59,7 @@ async function search(query, limit, config, options = {}) {
             }
             try {
                 const data = JSON.parse(stdout);
-                const tracks = (data.entries || []).map(entry => {
+                let 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];
@@ -82,6 +82,16 @@ async function search(query, limit, config, options = {}) {
                         _headers: entry.http_headers || data.http_headers || null
                     };
                 });
+
+                if (artistFilter) {
+                    tracks = tracks.filter(t => {
+                        const author = (t.author || '').toLowerCase();
+                        const title = (t.title || '').toLowerCase();
+                        return author.includes(artistFilter) || title.includes(artistFilter);
+                    }).slice(0, limit);
+                    log.info('YOUTUBE', `Filtered to ${tracks.length} tracks by artist "${options.artist}"`);
+                }
+
                 const elapsed = Date.now() - startTime;
                 log.info('YOUTUBE', `Found ${tracks.length} results (${elapsed}ms)`);
                 resolve({ tracks, source: 'youtube', searchTime: elapsed });

package/src/server.js

@@ -98,14 +98,14 @@ class Server {
                 if (!this._isProviderEnabled('youtube')) {
                     return res.status(400).json({ error: 'YouTube provider is disabled' });
                 }
-                const { q, limit = 10, type, sort } = req.query;
+                const { q, limit = 10, type, sort, artist } = req.query;
                 if (!q) return res.status(400).json({ error: 'Missing query parameter: q' });
 
-                const cacheKey = `yt:search:${q}:${limit}:${type}:${sort}`;
+                const cacheKey = `yt:search:${q}:${limit}:${type}:${sort}:${artist || ''}`;
                 const cached = cache.get(cacheKey);
                 if (cached) return res.json(cached);
 
-                const results = await youtube.search(q, parseInt(limit), this.config, { type, sort });
+                const results = await youtube.search(q, parseInt(limit), this.config, { type, sort, artist });
                 cache.set(cacheKey, results, this.config.cache.searchTTL);
                 res.json(results);
             } catch (error) {
@@ -149,14 +149,14 @@ class Server {
                 if (!this.config.spotify?.clientId) {
                     return res.status(400).json({ error: 'Spotify not configured' });
                 }
-                const { q, limit = 10 } = req.query;
+                const { q, limit = 10, artist } = req.query;
                 if (!q) return res.status(400).json({ error: 'Missing query parameter: q' });
 
-                const cacheKey = `sp:search:${q}:${limit}`;
+                const cacheKey = `sp:search:${q}:${limit}:${artist || ''}`;
                 const cached = cache.get(cacheKey);
                 if (cached) return res.json(cached);
 
-                const results = await spotify.search(q, parseInt(limit), this.config);
+                const results = await spotify.search(q, parseInt(limit), this.config, { artist });
                 cache.set(cacheKey, results, this.config.cache.searchTTL);
                 res.json(results);
             } catch (error) {
@@ -208,14 +208,14 @@ class Server {
                 if (!this._isProviderEnabled('soundcloud')) {
                     return res.status(400).json({ error: 'SoundCloud provider is disabled' });
                 }
-                const { q, limit = 10 } = req.query;
+                const { q, limit = 10, artist } = req.query;
                 if (!q) return res.status(400).json({ error: 'Missing query parameter: q' });
 
-                const cacheKey = `sc:search:${q}:${limit}`;
+                const cacheKey = `sc:search:${q}:${limit}:${artist || ''}`;
                 const cached = cache.get(cacheKey);
                 if (cached) return res.json(cached);
 
-                const results = await soundcloud.search(q, parseInt(limit), this.config);
+                const results = await soundcloud.search(q, parseInt(limit), this.config, { artist });
                 cache.set(cacheKey, results, this.config.cache.searchTTL);
                 res.json(results);
             } catch (error) {