@involvex/youtube-music-cli 0.0.18 → 0.0.19

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

@@ -0,0 +1,272 @@
+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.d.ts

@@ -0,0 +1,40 @@
+import type { SpotifyPlaylist } from '../../types/import.types.ts';
+declare class SpotifyImportService {
+    private readonly OEMBED_URL;
+    /**
+     * Extract playlist ID from various Spotify URL formats
+     */
+    extractPlaylistId(input: string): string | null;
+    /**
+     * Build a Spotify playlist URL from ID
+     */
+    buildPlaylistUrl(playlistId: string): string;
+    /**
+     * Fetch playlist metadata using Spotify oEmbed API
+     * This works for public playlists without authentication
+     */
+    fetchPlaylistMetadata(urlOrId: string): Promise<{
+        title: string;
+        url: string;
+    } | null>;
+    /**
+     * Fetch playlist tracks by scraping the Spotify Web API
+     * Note: This method has limitations and may not work for private playlists
+     */
+    fetchPlaylistTracks(playlistId: string): Promise<SpotifyPlaylist | null>;
+    /**
+     * Create a partial playlist when only metadata is available
+     * This is used when authentication is required but we have basic info
+     */
+    private createPartialPlaylist;
+    /**
+     * Fetch a Spotify playlist (with graceful degradation)
+     */
+    fetchPlaylist(urlOrId: string): Promise<SpotifyPlaylist | null>;
+    /**
+     * Validate if a playlist is accessible
+     */
+    validatePlaylist(urlOrId: string): Promise<boolean>;
+}
+export declare function getSpotifyImportService(): SpotifyImportService;
+export {};

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

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

package/dist/source/services/import/track-matcher.service.d.ts

@@ -0,0 +1,60 @@
+import type { Track } from '../../types/youtube-music.types.ts';
+import type { SpotifyTrack, YouTubeTrack, TrackMatch, MatchConfidence } from '../../types/import.types.ts';
+declare class TrackMatcherService {
+    private readonly musicService;
+    private searchCache;
+    private matchCache;
+    /**
+     * Build a search query from track metadata
+     */
+    buildSearchQuery(track: SpotifyTrack | YouTubeTrack): string;
+    /**
+     * Get track name from either type
+     */
+    getTrackName(track: SpotifyTrack | YouTubeTrack): string;
+    /**
+     * Calculate string similarity using Levenshtein distance
+     */
+    calculateSimilarity(str1: string, str2: string): number;
+    /**
+     * Calculate Levenshtein distance between two strings
+     */
+    levenshteinDistance(str1: string, str2: string): number;
+    /**
+     * Check if artists match (any overlap in artist lists)
+     */
+    artistsMatch(trackArtists: string[], candidateArtists: string[]): boolean;
+    /**
+     * Calculate duration proximity score (0-1)
+     */
+    durationScore(originalDuration: number, candidateDuration: number): number;
+    /**
+     * Score a track match based on multiple factors
+     */
+    scoreMatch(original: SpotifyTrack | YouTubeTrack, candidate: Track): number;
+    /**
+     * Determine confidence level from score
+     */
+    getConfidence(score: number): MatchConfidence;
+    /**
+     * Search YouTube Music for a track
+     */
+    searchTrack(track: SpotifyTrack | YouTubeTrack): Promise<Track[]>;
+    /**
+     * Find the best matching track on YouTube Music
+     */
+    findMatch(original: SpotifyTrack | YouTubeTrack): Promise<TrackMatch>;
+    /**
+     * Clear all caches
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        searchCache: number;
+        matchCache: number;
+    };
+}
+export declare function getTrackMatcherService(): TrackMatcherService;
+export {};