streamify-audio 2.0.0

package/src/providers/soundcloud.js

@@ -0,0 +1,166 @@
+const { spawn } = require('child_process');
+const { buildFfmpegArgs } = require('../filters/ffmpeg');
+const { registerStream, unregisterStream } = require('../utils/stream');
+const log = require('../utils/logger');
+
+async function search(query, limit, config) {
+    const startTime = Date.now();
+    log.info('SOUNDCLOUD', `Searching: "${query}" (limit: ${limit})`);
+
+    return new Promise((resolve, reject) => {
+        const args = [
+            '-q', '--no-warnings',
+            '--flat-playlist',
+            '--skip-download',
+            '-J',
+            `scsearch${limit}:${query}`
+        ];
+
+        const proc = spawn(config.ytdlpPath, args, {
+            env: { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH }
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        proc.stdout.on('data', (data) => { stdout += data; });
+        proc.stderr.on('data', (data) => { stderr += data; });
+
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                return reject(new Error(stderr || `yt-dlp exited with code ${code}`));
+            }
+            try {
+                const data = JSON.parse(stdout);
+                const tracks = (data.entries || []).map(entry => ({
+                    id: entry.id,
+                    title: entry.title,
+                    duration: entry.duration,
+                    author: entry.uploader,
+                    thumbnail: entry.thumbnails?.[0]?.url,
+                    uri: entry.url || entry.webpage_url,
+                    streamUrl: `/soundcloud/stream/${entry.id}`,
+                    source: 'soundcloud'
+                }));
+                const elapsed = Date.now() - startTime;
+                log.info('SOUNDCLOUD', `Found ${tracks.length} results (${elapsed}ms)`);
+                resolve({ tracks, source: 'soundcloud', searchTime: elapsed });
+            } catch (e) {
+                reject(new Error('Failed to parse yt-dlp output'));
+            }
+        });
+    });
+}
+
+async function getInfo(trackId, config) {
+    return new Promise((resolve, reject) => {
+        const args = [
+            '-q', '--no-warnings',
+            '--skip-download',
+            '-J',
+            `https://soundcloud.com/track/${trackId}`
+        ];
+
+        const proc = spawn(config.ytdlpPath, args, {
+            env: { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH }
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        proc.stdout.on('data', (data) => { stdout += data; });
+        proc.stderr.on('data', (data) => { stderr += data; });
+
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                return reject(new Error(stderr || `yt-dlp exited with code ${code}`));
+            }
+            try {
+                const data = JSON.parse(stdout);
+                resolve({
+                    id: data.id,
+                    title: data.title,
+                    duration: data.duration,
+                    author: data.uploader,
+                    thumbnail: data.thumbnail,
+                    uri: data.webpage_url,
+                    streamUrl: `/soundcloud/stream/${data.id}`,
+                    source: 'soundcloud'
+                });
+            } catch (e) {
+                reject(new Error('Failed to parse yt-dlp output'));
+            }
+        });
+    });
+}
+
+function stream(trackUrl, filters, config, res) {
+    const streamId = `sc-${Date.now()}`;
+    const streamStartTime = Date.now();
+
+    const filterStr = Object.entries(filters || {})
+        .filter(([k, v]) => v !== undefined && v !== null)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(', ') || 'none';
+
+    log.info('SOUNDCLOUD', `Stream: ${trackUrl} | Filters: ${filterStr}`);
+
+    res.setHeader('Content-Type', 'audio/ogg');
+    res.setHeader('Transfer-Encoding', 'chunked');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.flushHeaders();
+
+    const url = trackUrl.startsWith('http') ? trackUrl : `https://api.soundcloud.com/tracks/${trackUrl}/stream`;
+
+    const ytdlp = spawn(config.ytdlpPath, [
+        '-f', 'bestaudio/best',
+        '-o', '-',
+        url
+    ], {
+        env: { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH }
+    });
+
+    const ffmpegArgs = buildFfmpegArgs(filters, config);
+    const ffmpeg = spawn(config.ffmpegPath, ffmpegArgs);
+
+    registerStream(streamId, { ytdlp, ffmpeg, source: 'soundcloud', trackId: trackUrl, filters });
+
+    ytdlp.stdout.pipe(ffmpeg.stdin);
+    ffmpeg.stdout.pipe(res);
+
+    ytdlp.stderr.on('data', (data) => {
+        const msg = data.toString();
+        if (!msg.includes('[download]') && !msg.includes('ETA')) {
+            log.debug('SOUNDCLOUD', msg.trim());
+        }
+    });
+
+    ffmpeg.stderr.on('data', (data) => {
+        const msg = data.toString();
+        if (msg.includes('Error') || msg.includes('error')) {
+            log.error('FFMPEG', msg.trim());
+        }
+    });
+
+    const cleanup = (code = 0, error = null) => {
+        if (ytdlp && !ytdlp.killed) ytdlp.kill('SIGTERM');
+        if (ffmpeg && !ffmpeg.killed) ffmpeg.kill('SIGTERM');
+        unregisterStream(streamId, code, error);
+    };
+
+    ytdlp.on('error', (err) => cleanup(1, err));
+    ffmpeg.on('error', (err) => cleanup(1, err));
+    ffmpeg.on('close', (code) => {
+        const elapsed = Date.now() - streamStartTime;
+        log.info('SOUNDCLOUD', `Stream ended: ${trackUrl} | ${elapsed}ms | Code: ${code}`);
+        cleanup(code);
+    });
+    ytdlp.on('close', () => ffmpeg.stdin.end());
+    res.on('close', () => {
+        const elapsed = Date.now() - streamStartTime;
+        log.info('SOUNDCLOUD', `Client disconnected: ${trackUrl} | ${elapsed}ms`);
+        cleanup(0);
+    });
+}
+
+module.exports = { search, getInfo, stream };

package/src/providers/spotify.js

@@ -0,0 +1,216 @@
+const youtube = require('./youtube');
+const log = require('../utils/logger');
+
+let accessToken = null;
+let tokenExpiry = 0;
+
+const youtubeIdCache = new Map();
+const CACHE_TTL = 300000;
+
+async function getAccessToken(config) {
+    if (accessToken && Date.now() < tokenExpiry) {
+        return accessToken;
+    }
+
+    const { clientId, clientSecret } = config.spotify;
+    if (!clientId || !clientSecret) {
+        throw new Error('Spotify credentials not configured');
+    }
+
+    const response = await fetch('https://accounts.spotify.com/api/token', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Authorization': 'Basic ' + Buffer.from(`${clientId}:${clientSecret}`).toString('base64')
+        },
+        body: 'grant_type=client_credentials'
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to get Spotify access token');
+    }
+
+    const data = await response.json();
+    accessToken = data.access_token;
+    tokenExpiry = Date.now() + (data.expires_in * 1000) - 60000;
+
+    return accessToken;
+}
+
+async function spotifyApi(endpoint, config) {
+    const token = await getAccessToken(config);
+    const response = await fetch(`https://api.spotify.com/v1${endpoint}`, {
+        headers: {
+            'Authorization': `Bearer ${token}`
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error(`Spotify API error: ${response.status}`);
+    }
+
+    return response.json();
+}
+
+async function search(query, limit, config) {
+    const startTime = Date.now();
+    log.info('SPOTIFY', `Searching: "${query}" (limit: ${limit})`);
+
+    const data = await spotifyApi(`/search?q=${encodeURIComponent(query)}&type=track&limit=${limit}`, config);
+
+    const tracks = (data.tracks?.items || []).map(track => ({
+        id: track.id,
+        title: track.name,
+        author: track.artists.map(a => a.name).join(', '),
+        album: track.album.name,
+        duration: Math.floor(track.duration_ms / 1000),
+        thumbnail: track.album.images?.[0]?.url,
+        uri: track.external_urls.spotify,
+        streamUrl: `/spotify/stream/${track.id}`,
+        source: 'spotify'
+    }));
+
+    const elapsed = Date.now() - startTime;
+    log.info('SPOTIFY', `Found ${tracks.length} results (${elapsed}ms)`);
+    return { tracks, source: 'spotify', searchTime: elapsed };
+}
+
+async function getInfo(trackId, config) {
+    log.info('SPOTIFY', `Getting info: ${trackId}`);
+    const track = await spotifyApi(`/tracks/${trackId}`, config);
+
+    return {
+        id: track.id,
+        title: track.name,
+        author: track.artists.map(a => a.name).join(', '),
+        album: track.album.name,
+        duration: Math.floor(track.duration_ms / 1000),
+        thumbnail: track.album.images?.[0]?.url,
+        uri: track.external_urls.spotify,
+        streamUrl: `/spotify/stream/${track.id}`,
+        source: 'spotify'
+    };
+}
+
+async function resolveToYouTube(trackId, config) {
+    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 searchQuery = `${track.author} - ${track.title}`;
+    log.info('SPOTIFY', `Searching YouTube: "${searchQuery}"`);
+
+    const ytResults = await youtube.search(searchQuery, 1, config);
+
+    if (!ytResults.tracks?.length) {
+        throw new Error('Could not find matching YouTube video');
+    }
+
+    const videoId = ytResults.tracks[0].id;
+    youtubeIdCache.set(trackId, { videoId, expires: Date.now() + CACHE_TTL });
+    log.info('SPOTIFY', `Resolved to YouTube: ${videoId}`);
+
+    return videoId;
+}
+
+async function stream(trackId, filters, config, res) {
+    const startTime = Date.now();
+    log.info('SPOTIFY', `Stream: ${trackId}`);
+
+    try {
+        const videoId = await resolveToYouTube(trackId, config);
+        const elapsed = Date.now() - startTime;
+        log.info('SPOTIFY', `Resolution took ${elapsed}ms`);
+        return youtube.stream(videoId, filters, config, res);
+    } catch (error) {
+        log.error('SPOTIFY', error.message);
+        res.status(404).json({ error: error.message });
+    }
+}
+
+async function getPlaylist(playlistId, config) {
+    log.info('SPOTIFY', `Getting playlist: ${playlistId}`);
+
+    const data = await spotifyApi(`/playlists/${playlistId}`, config);
+
+    const tracks = (data.tracks?.items || [])
+        .filter(item => item.track)
+        .map(item => ({
+            id: item.track.id,
+            title: item.track.name,
+            author: item.track.artists.map(a => a.name).join(', '),
+            album: item.track.album.name,
+            duration: Math.floor(item.track.duration_ms / 1000),
+            thumbnail: item.track.album.images?.[0]?.url,
+            uri: item.track.external_urls.spotify,
+            streamUrl: `/spotify/stream/${item.track.id}`,
+            source: 'spotify'
+        }));
+
+    log.info('SPOTIFY', `Playlist loaded: ${data.name} (${tracks.length} tracks)`);
+
+    return {
+        id: playlistId,
+        title: data.name,
+        author: data.owner?.display_name,
+        thumbnail: data.images?.[0]?.url,
+        tracks,
+        source: 'spotify'
+    };
+}
+
+async function getAlbum(albumId, config) {
+    log.info('SPOTIFY', `Getting album: ${albumId}`);
+
+    const data = await spotifyApi(`/albums/${albumId}`, config);
+
+    const tracks = (data.tracks?.items || []).map(track => ({
+        id: track.id,
+        title: track.name,
+        author: track.artists.map(a => a.name).join(', '),
+        album: data.name,
+        duration: Math.floor(track.duration_ms / 1000),
+        thumbnail: data.images?.[0]?.url,
+        uri: track.external_urls.spotify,
+        streamUrl: `/spotify/stream/${track.id}`,
+        source: 'spotify'
+    }));
+
+    log.info('SPOTIFY', `Album loaded: ${data.name} (${tracks.length} tracks)`);
+
+    return {
+        id: albumId,
+        title: data.name,
+        author: data.artists.map(a => a.name).join(', '),
+        thumbnail: data.images?.[0]?.url,
+        tracks,
+        source: 'spotify'
+    };
+}
+
+async function getRecommendations(trackId, limit, config) {
+    log.info('SPOTIFY', `Getting recommendations for: ${trackId} (limit: ${limit})`);
+
+    const data = await spotifyApi(`/recommendations?seed_tracks=${trackId}&limit=${limit}`, config);
+
+    const tracks = (data.tracks || []).map(track => ({
+        id: track.id,
+        title: track.name,
+        author: track.artists.map(a => a.name).join(', '),
+        album: track.album.name,
+        duration: Math.floor(track.duration_ms / 1000),
+        thumbnail: track.album.images?.[0]?.url,
+        uri: track.external_urls.spotify,
+        streamUrl: `/spotify/stream/${track.id}`,
+        source: 'spotify',
+        isAutoplay: true
+    }));
+
+    log.info('SPOTIFY', `Found ${tracks.length} recommendations`);
+    return { tracks, source: 'spotify' };
+}
+
+module.exports = { search, getInfo, stream, resolveToYouTube, getPlaylist, getAlbum, getRecommendations };

package/src/providers/youtube.js

@@ -0,0 +1,320 @@
+const { spawn } = require('child_process');
+const { buildFfmpegArgs } = require('../filters/ffmpeg');
+const { registerStream, unregisterStream } = require('../utils/stream');
+const log = require('../utils/logger');
+
+async function search(query, limit, config) {
+    const startTime = Date.now();
+    log.info('YOUTUBE', `Searching: "${query}" (limit: ${limit})`);
+
+    return new Promise((resolve, reject) => {
+        const args = [
+            '-q', '--no-warnings',
+            '--flat-playlist',
+            '--skip-download',
+            '-J',
+            `ytsearch${limit}:${query}`
+        ];
+
+        if (config.cookiesPath) {
+            args.unshift('--cookies', config.cookiesPath);
+        }
+
+        const proc = spawn(config.ytdlpPath, args, {
+            env: { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH }
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        proc.stdout.on('data', (data) => { stdout += data; });
+        proc.stderr.on('data', (data) => { stderr += data; });
+
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                return reject(new Error(stderr || `yt-dlp exited with code ${code}`));
+            }
+            try {
+                const data = JSON.parse(stdout);
+                const tracks = (data.entries || []).map(entry => ({
+                    id: entry.id,
+                    title: entry.title,
+                    duration: entry.duration,
+                    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'
+                }));
+                const elapsed = Date.now() - startTime;
+                log.info('YOUTUBE', `Found ${tracks.length} results (${elapsed}ms)`);
+                resolve({ tracks, source: 'youtube', searchTime: elapsed });
+            } catch (e) {
+                reject(new Error('Failed to parse yt-dlp output'));
+            }
+        });
+    });
+}
+
+async function getInfo(videoId, config) {
+    log.info('YOUTUBE', `Getting info: ${videoId}`);
+
+    return new Promise((resolve, reject) => {
+        const args = [
+            '-q', '--no-warnings',
+            '--skip-download',
+            '-J',
+            `https://www.youtube.com/watch?v=${videoId}`
+        ];
+
+        if (config.cookiesPath) {
+            args.unshift('--cookies', config.cookiesPath);
+        }
+
+        const proc = spawn(config.ytdlpPath, args, {
+            env: { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH }
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        proc.stdout.on('data', (data) => { stdout += data; });
+        proc.stderr.on('data', (data) => { stderr += data; });
+
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                return reject(new Error(stderr || `yt-dlp exited with code ${code}`));
+            }
+            try {
+                const data = JSON.parse(stdout);
+                resolve({
+                    id: data.id,
+                    title: data.title,
+                    duration: data.duration,
+                    author: data.channel || data.uploader,
+                    thumbnail: data.thumbnail,
+                    uri: data.webpage_url,
+                    streamUrl: `/youtube/stream/${data.id}`,
+                    source: 'youtube'
+                });
+            } catch (e) {
+                reject(new Error('Failed to parse yt-dlp output'));
+            }
+        });
+    });
+}
+
+async function stream(videoId, filters, config, res) {
+    const streamId = `yt-${videoId}-${Date.now()}`;
+    const streamStartTime = Date.now();
+
+    const filterStr = Object.entries(filters || {})
+        .filter(([k, v]) => v !== undefined && v !== null)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(', ') || 'none';
+
+    log.info('YOUTUBE', `Stream: ${videoId} | Filters: ${filterStr}`);
+
+    res.setHeader('Content-Type', 'audio/ogg');
+    res.setHeader('Transfer-Encoding', 'chunked');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.flushHeaders();
+
+    const ytdlpArgs = [
+        '-f', '18/bestaudio/best',
+        '-o', '-',
+        `https://www.youtube.com/watch?v=${videoId}`
+    ];
+
+    if (config.cookiesPath) {
+        ytdlpArgs.unshift('--cookies', config.cookiesPath);
+    }
+
+    const ytdlp = spawn(config.ytdlpPath, ytdlpArgs, {
+        env: { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH }
+    });
+
+    const ffmpegArgs = buildFfmpegArgs(filters, config);
+    const ffmpeg = spawn(config.ffmpegPath, ffmpegArgs);
+
+    registerStream(streamId, { ytdlp, ffmpeg, videoId, source: 'youtube', filters });
+
+    let bytesReceived = 0;
+    let bytesSent = 0;
+
+    ytdlp.stdout.on('data', (chunk) => {
+        bytesReceived += chunk.length;
+    });
+
+    ffmpeg.stdout.on('data', (chunk) => {
+        bytesSent += chunk.length;
+    });
+
+    ytdlp.stdout.pipe(ffmpeg.stdin);
+    ffmpeg.stdout.pipe(res);
+
+    ytdlp.stderr.on('data', (data) => {
+        const msg = data.toString();
+        if (!msg.includes('[download]') && !msg.includes('ETA')) {
+            log.debug('YTDLP', msg.trim());
+        }
+    });
+
+    ffmpeg.stderr.on('data', (data) => {
+        const msg = data.toString();
+        if (msg.includes('Error') || msg.includes('error')) {
+            log.error('FFMPEG', msg.trim());
+        }
+    });
+
+    const cleanup = (code = 0, error = null) => {
+        if (ytdlp && !ytdlp.killed) ytdlp.kill('SIGTERM');
+        if (ffmpeg && !ffmpeg.killed) ffmpeg.kill('SIGTERM');
+        unregisterStream(streamId, code, error);
+    };
+
+    ytdlp.on('error', (error) => {
+        log.error('YOUTUBE', videoId, error.message);
+        cleanup(1, error);
+    });
+
+    ffmpeg.on('error', (error) => {
+        log.error('FFMPEG', videoId, error.message);
+        cleanup(1, error);
+    });
+
+    ffmpeg.on('close', (code) => {
+        const elapsed = Date.now() - streamStartTime;
+        log.info('YOUTUBE', `Stream ended: ${videoId} | Code: ${code} | ${elapsed}ms | Received: ${bytesReceived} | Sent: ${bytesSent}`);
+        cleanup(code);
+    });
+
+    ytdlp.on('close', (code) => {
+        if (code !== 0 && code !== null) {
+            log.debug('YOUTUBE', `yt-dlp ended for ${videoId} (code: ${code})`);
+        }
+        ffmpeg.stdin.end();
+    });
+
+    res.on('close', () => {
+        const elapsed = Date.now() - streamStartTime;
+        log.info('YOUTUBE', `Client disconnected: ${videoId} | ${elapsed}ms | Received: ${bytesReceived} | Sent: ${bytesSent}`);
+        cleanup(0);
+    });
+}
+
+async function getPlaylist(playlistId, config) {
+    log.info('YOUTUBE', `Getting playlist: ${playlistId}`);
+
+    return new Promise((resolve, reject) => {
+        const args = [
+            '-q', '--no-warnings',
+            '--flat-playlist',
+            '--skip-download',
+            '-J',
+            `https://www.youtube.com/playlist?list=${playlistId}`
+        ];
+
+        if (config.cookiesPath) {
+            args.unshift('--cookies', config.cookiesPath);
+        }
+
+        const proc = spawn(config.ytdlpPath, args, {
+            env: { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH }
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        proc.stdout.on('data', (data) => { stdout += data; });
+        proc.stderr.on('data', (data) => { stderr += data; });
+
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                return reject(new Error(stderr || `yt-dlp exited with code ${code}`));
+            }
+            try {
+                const data = JSON.parse(stdout);
+                const tracks = (data.entries || []).map(entry => ({
+                    id: entry.id,
+                    title: entry.title,
+                    duration: entry.duration,
+                    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'
+                }));
+                log.info('YOUTUBE', `Playlist loaded: ${data.title || playlistId} (${tracks.length} tracks)`);
+                resolve({
+                    id: playlistId,
+                    title: data.title,
+                    author: data.channel || data.uploader,
+                    thumbnail: data.thumbnails?.[0]?.url,
+                    tracks,
+                    source: 'youtube'
+                });
+            } catch (e) {
+                reject(new Error('Failed to parse playlist data'));
+            }
+        });
+    });
+}
+
+async function getRelated(videoId, limit, config) {
+    log.info('YOUTUBE', `Getting related for: ${videoId} (limit: ${limit})`);
+
+    return new Promise((resolve, reject) => {
+        const args = [
+            '-q', '--no-warnings',
+            '--flat-playlist',
+            '--skip-download',
+            '-J',
+            `https://www.youtube.com/watch?v=${videoId}&list=RD${videoId}`
+        ];
+
+        if (config.cookiesPath) {
+            args.unshift('--cookies', config.cookiesPath);
+        }
+
+        const proc = spawn(config.ytdlpPath, args, {
+            env: { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH }
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        proc.stdout.on('data', (data) => { stdout += data; });
+        proc.stderr.on('data', (data) => { stderr += data; });
+
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                return reject(new Error(stderr || `yt-dlp exited with code ${code}`));
+            }
+            try {
+                const data = JSON.parse(stdout);
+                const entries = data.entries || [];
+                const tracks = entries
+                    .filter(entry => entry.id !== videoId)
+                    .slice(0, limit)
+                    .map(entry => ({
+                        id: entry.id,
+                        title: entry.title,
+                        duration: entry.duration,
+                        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',
+                        isAutoplay: true
+                    }));
+                log.info('YOUTUBE', `Found ${tracks.length} related tracks`);
+                resolve({ tracks, source: 'youtube' });
+            } catch (e) {
+                reject(new Error('Failed to parse related tracks'));
+            }
+        });
+    });
+}
+
+module.exports = { search, getInfo, stream, getPlaylist, getRelated };