@involvex/youtube-music-cli 0.0.47 → 0.0.48

package/dist/source/services/import/import.service.js

@@ -1,272 +0,0 @@
-import { getYouTubeImportService } from "./youtube-import.service.js";
-import { getSpotifyImportService } from "./spotify.service.js";
-import { getTrackMatcherService } from "./track-matcher.service.js";
-import { getConfigService } from "../config/config.service.js";
-import { logger } from "../logger/logger.service.js";
-// Helper to get track name from either Spotify or YouTube track
-function getTrackName(track) {
-    return track.name || track.title;
-}
-class ImportService {
-    progressCallbacks = new Set();
-    currentImport = null;
-    /**
-     * Subscribe to import progress updates
-     */
-    onProgress(callback) {
-        this.progressCallbacks.add(callback);
-        return () => {
-            this.progressCallbacks.delete(callback);
-        };
-    }
-    /**
-     * Emit progress to all subscribers
-     */
-    emitProgress(progress) {
-        for (const callback of this.progressCallbacks) {
-            callback(progress);
-        }
-    }
-    /**
-     * Create a unique playlist ID
-     */
-    generatePlaylistId() {
-        return `import_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-    }
-    /**
-     * Save imported playlist to config
-     */
-    savePlaylist(name, tracks) {
-        const configService = getConfigService();
-        const playlist = {
-            playlistId: this.generatePlaylistId(),
-            name,
-            tracks,
-        };
-        // Get existing playlists and add the new one
-        const existingPlaylists = configService.get('playlists') ?? [];
-        const updatedPlaylists = [...existingPlaylists, playlist];
-        configService.set('playlists', updatedPlaylists);
-        logger.info('ImportService', 'Playlist saved to config', {
-            playlistId: playlist.playlistId,
-            trackCount: tracks.length,
-        });
-        return playlist.playlistId;
-    }
-    /**
-     * Import a playlist from Spotify or YouTube
-     */
-    async importPlaylist(source, urlOrId, customName, signal) {
-        const startTime = Date.now();
-        this.currentImport = { source, url: urlOrId, startTime };
-        // Initial progress
-        this.emitProgress({
-            status: 'fetching',
-            current: 0,
-            total: 0,
-            message: `Fetching ${source} playlist...`,
-        });
-        let originalTracks = [];
-        let playlistName = customName ?? `Imported ${source} playlist`;
-        try {
-            // Step 1: Fetch playlist
-            if (source === 'youtube') {
-                const youtubeService = getYouTubeImportService();
-                const playlist = await youtubeService.fetchPlaylist(urlOrId);
-                if (!playlist) {
-                    throw new Error('Failed to fetch YouTube playlist. Please check the URL/ID.');
-                }
-                originalTracks = playlist.tracks;
-                playlistName = customName ?? playlist.name;
-            }
-            else {
-                const spotifyService = getSpotifyImportService();
-                const playlist = await spotifyService.fetchPlaylist(urlOrId);
-                if (!playlist) {
-                    throw new Error('Failed to fetch Spotify playlist. It may be private or invalid.');
-                }
-                if (playlist.tracks.length === 0) {
-                    throw new Error('No tracks found. The playlist may be private or require authentication.');
-                }
-                originalTracks = playlist.tracks;
-                playlistName = customName ?? playlist.name;
-            }
-            const total = originalTracks.length;
-            // Check for abort
-            if (signal?.aborted) {
-                this.emitProgress({
-                    status: 'cancelled',
-                    current: 0,
-                    total,
-                    message: 'Import cancelled',
-                });
-                throw new Error('Import cancelled');
-            }
-            // Step 2: Match tracks
-            this.emitProgress({
-                status: 'matching',
-                current: 0,
-                total,
-                message: 'Matching tracks...',
-            });
-            const trackMatcher = getTrackMatcherService();
-            const matchedTracks = [];
-            const errors = [];
-            let matched = 0;
-            let failed = 0;
-            for (let i = 0; i < originalTracks.length; i++) {
-                // Check for abort
-                if (signal?.aborted) {
-                    this.emitProgress({
-                        status: 'cancelled',
-                        current: i,
-                        total,
-                        currentTrack: originalTracks[i]
-                            ? getTrackName(originalTracks[i])
-                            : undefined,
-                        message: 'Import cancelled',
-                    });
-                    throw new Error('Import cancelled');
-                }
-                const originalTrack = originalTracks[i];
-                const trackName = getTrackName(originalTrack);
-                this.emitProgress({
-                    status: 'matching',
-                    current: i,
-                    total,
-                    currentTrack: trackName,
-                    message: `Matching "${trackName}"...`,
-                });
-                const match = await trackMatcher.findMatch(originalTrack);
-                if (match.matchedTrack) {
-                    matchedTracks.push(match.matchedTrack);
-                    matched++;
-                }
-                else {
-                    failed++;
-                    const errorMsg = match.error
-                        ? `${trackName}: ${match.error}`
-                        : `No match found for "${trackName}"`;
-                    errors.push(errorMsg);
-                }
-                // Throttle progress updates (every 5 tracks or at the end)
-                if (i % 5 === 0 || i === total - 1) {
-                    this.emitProgress({
-                        status: 'matching',
-                        current: i + 1,
-                        total,
-                        currentTrack: trackName,
-                        message: `Matched ${matched}/${total} tracks`,
-                    });
-                }
-            }
-            // Step 3: Create playlist
-            this.emitProgress({
-                status: 'creating',
-                current: total,
-                total,
-                message: 'Creating playlist...',
-            });
-            const playlistId = this.savePlaylist(playlistName, matchedTracks);
-            // Final progress
-            this.emitProgress({
-                status: 'completed',
-                current: total,
-                total,
-                message: `Import completed: ${matched} tracks matched`,
-            });
-            const result = {
-                playlistId,
-                playlistName,
-                source,
-                total,
-                matched,
-                failed,
-                matches: [], // Could be populated if needed for detailed results
-                errors,
-                duration: Date.now() - startTime,
-            };
-            logger.info('ImportService', 'Import completed', {
-                playlistId,
-                playlistName,
-                source,
-                total,
-                matched,
-                failed,
-                duration: result.duration,
-            });
-            return result;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            logger.error('ImportService', 'Import failed', {
-                source,
-                url: urlOrId,
-                error: message,
-            });
-            if (message === 'Import cancelled') {
-                throw error;
-            }
-            this.emitProgress({
-                status: 'failed',
-                current: 0,
-                total: originalTracks.length,
-                message: `Import failed: ${message}`,
-            });
-            throw error;
-        }
-        finally {
-            this.currentImport = null;
-        }
-    }
-    /**
-     * Validate a playlist URL/ID before importing
-     */
-    async validatePlaylist(source, urlOrId) {
-        try {
-            if (source === 'youtube') {
-                const service = getYouTubeImportService();
-                return await service.validatePlaylist(urlOrId);
-            }
-            else {
-                const service = getSpotifyImportService();
-                return await service.validatePlaylist(urlOrId);
-            }
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Get current import status
-     */
-    getCurrentImport() {
-        if (!this.currentImport)
-            return null;
-        return {
-            source: this.currentImport.source,
-            url: this.currentImport.url,
-            elapsed: Date.now() - this.currentImport.startTime,
-        };
-    }
-    /**
-     * Cancel the current import
-     */
-    cancelImport() {
-        this.currentImport = null;
-        this.emitProgress({
-            status: 'cancelled',
-            current: 0,
-            total: 0,
-            message: 'Import cancelled',
-        });
-    }
-}
-// Singleton instance
-let importServiceInstance = null;
-export function getImportService() {
-    if (!importServiceInstance) {
-        importServiceInstance = new ImportService();
-    }
-    return importServiceInstance;
-}

package/dist/source/services/import/spotify.service.js

@@ -1,171 +0,0 @@
-import { logger } from "../logger/logger.service.js";
-class SpotifyImportService {
-    OEMBED_URL = 'https://open.spotify.com/oembed';
-    /**
-     * Extract playlist ID from various Spotify URL formats
-     */
-    extractPlaylistId(input) {
-        // Direct playlist ID (base62 string, typically 22 characters)
-        if (/^[A-Za-z0-9]{22}$/.test(input)) {
-            return input;
-        }
-        // spotify:playlist:ID format
-        const uriMatch = input.match(/spotify:playlist:([A-Za-z0-9]+)/);
-        if (uriMatch) {
-            return uriMatch[1] ?? null;
-        }
-        // open.spotify.com/playlist/ID format
-        const urlMatch = input.match(/open\.spotify\.com\/playlist\/([A-Za-z0-9]+)/);
-        if (urlMatch) {
-            return urlMatch[1] ?? null;
-        }
-        return null;
-    }
-    /**
-     * Build a Spotify playlist URL from ID
-     */
-    buildPlaylistUrl(playlistId) {
-        return `https://open.spotify.com/playlist/${playlistId}`;
-    }
-    /**
-     * Fetch playlist metadata using Spotify oEmbed API
-     * This works for public playlists without authentication
-     */
-    async fetchPlaylistMetadata(urlOrId) {
-        const playlistId = this.extractPlaylistId(urlOrId);
-        if (!playlistId) {
-            return null;
-        }
-        const playlistUrl = this.buildPlaylistUrl(playlistId);
-        const oembedUrl = `${this.OEMBED_URL}?url=${encodeURIComponent(playlistUrl)}`;
-        try {
-            logger.debug('SpotifyImportService', 'Fetching oEmbed metadata', {
-                playlistId,
-            });
-            const response = await fetch(oembedUrl);
-            if (!response.ok) {
-                logger.warn('SpotifyImportService', 'oEmbed request failed', {
-                    status: response.status,
-                    playlistId,
-                });
-                return null;
-            }
-            const data = (await response.json());
-            return {
-                title: data.title || 'Unknown Playlist',
-                url: playlistUrl,
-            };
-        }
-        catch (error) {
-            logger.error('SpotifyImportService', 'oEmbed fetch failed', {
-                playlistId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return null;
-        }
-    }
-    /**
-     * Fetch playlist tracks by scraping the Spotify Web API
-     * Note: This method has limitations and may not work for private playlists
-     */
-    async fetchPlaylistTracks(playlistId) {
-        const metadata = await this.fetchPlaylistMetadata(playlistId);
-        if (!metadata) {
-            return null;
-        }
-        try {
-            // Use Spotify's Web API endpoint for playlist tracks (no auth required for public playlists)
-            const apiUrl = `https://api.spotify.com/v1/playlists/${playlistId}/tracks?limit=100`;
-            logger.debug('SpotifyImportService', 'Fetching tracks from API', {
-                playlistId,
-            });
-            const response = await fetch(apiUrl, {
-                headers: {
-                    Accept: 'application/json',
-                },
-            });
-            // API may require auth for some playlists
-            if (!response.ok) {
-                if (response.status === 401 || response.status === 403) {
-                    logger.warn('SpotifyImportService', 'Playlist requires authentication', {
-                        playlistId,
-                        status: response.status,
-                    });
-                    return this.createPartialPlaylist(playlistId, metadata);
-                }
-                return null;
-            }
-            const data = (await response.json());
-            const tracks = data.items
-                ?.filter(item => item.track)
-                .map(item => ({
-                id: item.track.id ?? '',
-                name: item.track.name ?? 'Unknown Track',
-                artists: item.track.artists?.map(a => a.name ?? 'Unknown Artist') ?? [],
-                album: item.track.album?.name,
-                duration: Math.round((item.track.duration_ms ?? 0) / 1000),
-            })) ?? [];
-            return {
-                id: playlistId,
-                name: metadata.title,
-                tracks,
-                isPublic: true,
-                url: metadata.url,
-            };
-        }
-        catch (error) {
-            logger.error('SpotifyImportService', 'Failed to fetch playlist', {
-                playlistId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return null;
-        }
-    }
-    /**
-     * Create a partial playlist when only metadata is available
-     * This is used when authentication is required but we have basic info
-     */
-    createPartialPlaylist(playlistId, metadata) {
-        logger.info('SpotifyImportService', 'Creating partial playlist (auth required)', {
-            playlistId,
-        });
-        return {
-            id: playlistId,
-            name: metadata.title,
-            tracks: [],
-            isPublic: false,
-            url: metadata.url,
-        };
-    }
-    /**
-     * Fetch a Spotify playlist (with graceful degradation)
-     */
-    async fetchPlaylist(urlOrId) {
-        const playlistId = this.extractPlaylistId(urlOrId);
-        if (!playlistId) {
-            logger.warn('SpotifyImportService', 'Invalid Spotify playlist URL or ID', {
-                input: urlOrId,
-            });
-            return null;
-        }
-        logger.info('SpotifyImportService', 'Fetching Spotify playlist', {
-            playlistId,
-        });
-        return this.fetchPlaylistTracks(playlistId);
-    }
-    /**
-     * Validate if a playlist is accessible
-     */
-    async validatePlaylist(urlOrId) {
-        const playlist = await this.fetchPlaylist(urlOrId);
-        return playlist !== null;
-    }
-}
-// Singleton instance
-let spotifyImportServiceInstance = null;
-export function getSpotifyImportService() {
-    if (!spotifyImportServiceInstance) {
-        spotifyImportServiceInstance = new SpotifyImportService();
-    }
-    return spotifyImportServiceInstance;
-}