@involvex/youtube-music-cli 0.0.47 → 0.0.48

package/dist/source/services/import/track-matcher.service.js

@@ -1,271 +0,0 @@
-import { getMusicService } from "../youtube-music/api.js";
-import { logger } from "../logger/logger.service.js";
-class TrackMatcherService {
-    musicService = getMusicService();
-    searchCache = new Map();
-    matchCache = new Map();
-    /**
-     * Build a search query from track metadata
-     */
-    buildSearchQuery(track) {
-        // Combine artist and title for best results
-        const artists = track.artists.slice(0, 2).join(', '); // Use up to 2 artists
-        const name = track.name || track.title;
-        return `${artists} ${name}`.trim();
-    }
-    /**
-     * Get track name from either type
-     */
-    getTrackName(track) {
-        return track.name || track.title;
-    }
-    /**
-     * Calculate string similarity using Levenshtein distance
-     */
-    calculateSimilarity(str1, str2) {
-        const s1 = str1.toLowerCase().normalize();
-        const s2 = str2.toLowerCase().normalize();
-        // Exact match
-        if (s1 === s2)
-            return 1;
-        // Check if one contains the other
-        if (s1.includes(s2) || s2.includes(s1))
-            return 0.9;
-        // Simple Levenshtein-based similarity
-        const longer = s1.length > s2.length ? s1 : s2;
-        const shorter = s1.length > s2.length ? s2 : s1;
-        if (longer.length === 0)
-            return 1;
-        const editDistance = this.levenshteinDistance(longer, shorter);
-        return (longer.length - editDistance) / longer.length;
-    }
-    /**
-     * Calculate Levenshtein distance between two strings
-     */
-    levenshteinDistance(str1, str2) {
-        const matrix = [];
-        for (let i = 0; i <= str2.length; i++) {
-            matrix[i] = [i];
-        }
-        for (let j = 0; j <= str1.length; j++) {
-            if (matrix[0]) {
-                matrix[0][j] = j;
-            }
-        }
-        for (let i = 1; i <= str2.length; i++) {
-            const row = matrix[i];
-            if (!row)
-                continue;
-            const prevRow = matrix[i - 1];
-            if (!prevRow)
-                continue;
-            for (let j = 1; j <= str1.length; j++) {
-                if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
-                    row[j] = prevRow[j - 1] ?? 0;
-                }
-                else {
-                    row[j] = Math.min((prevRow[j - 1] ?? 0) + 1, // substitution
-                    (row[j - 1] ?? 0) + 1, // insertion
-                    (prevRow[j] ?? 0) + 1);
-                }
-            }
-        }
-        const lastRow = matrix[str2.length];
-        return lastRow?.[str1.length] ?? 0;
-    }
-    /**
-     * Check if artists match (any overlap in artist lists)
-     */
-    artistsMatch(trackArtists, candidateArtists) {
-        const normalizedTrackArtists = trackArtists
-            .map(a => a.toLowerCase().trim())
-            .filter(a => a.length > 0);
-        // candidateArtists are strings directly from the track
-        const normalizedCandidateArtists = candidateArtists
-            .map(a => a.toLowerCase().trim())
-            .filter(a => a.length > 0);
-        // Check for any artist name overlap
-        return normalizedTrackArtists.some(trackArtist => normalizedCandidateArtists.some(candidateArtist => candidateArtist.includes(trackArtist) ||
-            trackArtist.includes(candidateArtist)));
-    }
-    /**
-     * Calculate duration proximity score (0-1)
-     */
-    durationScore(originalDuration, candidateDuration) {
-        if (!originalDuration || !candidateDuration)
-            return 0.5; // Neutral if either is missing
-        const diff = Math.abs(originalDuration - candidateDuration);
-        const maxDiff = Math.max(originalDuration, candidateDuration) * 0.3; // 30% tolerance
-        if (diff === 0)
-            return 1;
-        if (diff <= maxDiff)
-            return 1 - diff / maxDiff;
-        return 0;
-    }
-    /**
-     * Score a track match based on multiple factors
-     */
-    scoreMatch(original, candidate) {
-        let score = 0;
-        const weights = {
-            title: 0.5,
-            artist: 0.3,
-            duration: 0.2,
-        };
-        // Title similarity
-        const titleSimilarity = this.calculateSimilarity(this.getTrackName(original), candidate.title);
-        score += titleSimilarity * weights.title;
-        // Artist match
-        const artistMatch = this.artistsMatch(original.artists, candidate.artists.map(a => a.name))
-            ? 1
-            : 0;
-        score += artistMatch * weights.artist;
-        // Duration proximity
-        const durationScore = this.durationScore(original.duration, candidate.duration ?? 0);
-        score += durationScore * weights.duration;
-        return score;
-    }
-    /**
-     * Determine confidence level from score
-     */
-    getConfidence(score) {
-        if (score >= 0.85)
-            return 'high';
-        if (score >= 0.7)
-            return 'medium';
-        if (score >= 0.5)
-            return 'low';
-        return 'none';
-    }
-    /**
-     * Search YouTube Music for a track
-     */
-    async searchTrack(track) {
-        const query = this.buildSearchQuery(track);
-        const cacheKey = `track:${query}`;
-        // Check cache first
-        const cached = this.searchCache.get(cacheKey);
-        if (cached) {
-            logger.debug('TrackMatcherService', 'Using cached search results', {
-                query,
-            });
-            return cached;
-        }
-        try {
-            logger.debug('TrackMatcherService', 'Searching for track', { query });
-            const response = await this.musicService.search(query, {
-                type: 'songs',
-                limit: 10,
-            });
-            const results = response.results
-                .filter(r => r.type === 'song')
-                .map(r => r.data);
-            // Cache results
-            this.searchCache.set(cacheKey, results);
-            return results;
-        }
-        catch (error) {
-            logger.error('TrackMatcherService', 'Track search failed', {
-                query,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return [];
-        }
-    }
-    /**
-     * Find the best matching track on YouTube Music
-     */
-    async findMatch(original) {
-        // Create a unique key for this track
-        const trackKey = `${original.artists[0] ?? ''}-${this.getTrackName(original)}-${original.duration}`;
-        const cached = this.matchCache.get(trackKey);
-        if (cached) {
-            logger.debug('TrackMatcherService', 'Using cached match', {
-                track: this.getTrackName(original),
-            });
-            return cached;
-        }
-        try {
-            const candidates = await this.searchTrack(original);
-            if (candidates.length === 0) {
-                const noMatch = {
-                    originalTrack: original,
-                    matchedTrack: null,
-                    confidence: 'none',
-                };
-                this.matchCache.set(trackKey, noMatch);
-                return noMatch;
-            }
-            // Score all candidates
-            const scoredCandidates = candidates.map(candidate => ({
-                ...candidate,
-                score: this.scoreMatch(original, candidate),
-            }));
-            // Sort by score descending
-            scoredCandidates.sort((a, b) => b.score - a.score);
-            const best = scoredCandidates[0];
-            if (!best) {
-                const noMatch = {
-                    originalTrack: original,
-                    matchedTrack: null,
-                    confidence: 'none',
-                };
-                this.matchCache.set(trackKey, noMatch);
-                return noMatch;
-            }
-            const { score, ...matchedTrack } = best;
-            const confidence = this.getConfidence(score);
-            const match = {
-                originalTrack: original,
-                matchedTrack: matchedTrack,
-                confidence,
-            };
-            logger.debug('TrackMatcherService', 'Track matched', {
-                original: this.getTrackName(original),
-                matched: matchedTrack.title,
-                confidence,
-                score,
-            });
-            this.matchCache.set(trackKey, match);
-            return match;
-        }
-        catch (error) {
-            logger.error('TrackMatcherService', 'Match finding failed', {
-                track: this.getTrackName(original),
-                error: error instanceof Error ? error.message : String(error),
-            });
-            const errorMatch = {
-                originalTrack: original,
-                matchedTrack: null,
-                confidence: 'none',
-                error: error instanceof Error ? error.message : String(error),
-            };
-            return errorMatch;
-        }
-    }
-    /**
-     * Clear all caches
-     */
-    clearCache() {
-        this.searchCache.clear();
-        this.matchCache.clear();
-        logger.debug('TrackMatcherService', 'Caches cleared');
-    }
-    /**
-     * Get cache statistics
-     */
-    getCacheStats() {
-        return {
-            searchCache: this.searchCache.size,
-            matchCache: this.matchCache.size,
-        };
-    }
-}
-// Singleton instance
-let trackMatcherServiceInstance = null;
-export function getTrackMatcherService() {
-    if (!trackMatcherServiceInstance) {
-        trackMatcherServiceInstance = new TrackMatcherService();
-    }
-    return trackMatcherServiceInstance;
-}

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

@@ -1,84 +0,0 @@
-import { getMusicService } from "../youtube-music/api.js";
-import { logger } from "../logger/logger.service.js";
-class YouTubeImportService {
-    /**
-     * Extract playlist ID from various YouTube URL formats
-     */
-    extractPlaylistId(input) {
-        // Direct playlist ID
-        if (/^[-_A-Za-z0-9]{10,}$/.test(input)) {
-            return input;
-        }
-        // youtube.com/watch?v=...&list=...
-        const watchMatch = input.match(/[?&]list=([-_A-Za-z0-9]+)/);
-        if (watchMatch) {
-            return watchMatch[1] ?? null;
-        }
-        // youtube.com/playlist?list=...
-        const playlistMatch = input.match(/[?&]list=([-_A-Za-z0-9]+)/);
-        if (playlistMatch) {
-            return playlistMatch[1] ?? null;
-        }
-        return null;
-    }
-    /**
-     * Fetch a YouTube playlist and normalize to import format
-     */
-    async fetchPlaylist(urlOrId) {
-        const playlistId = this.extractPlaylistId(urlOrId);
-        if (!playlistId) {
-            logger.warn('YouTubeImportService', 'Invalid YouTube playlist URL or ID', {
-                input: urlOrId,
-            });
-            return null;
-        }
-        try {
-            logger.info('YouTubeImportService', 'Fetching YouTube playlist', {
-                playlistId,
-            });
-            const musicService = getMusicService();
-            const playlist = await musicService.getPlaylist(playlistId);
-            // Normalize to YouTubePlaylist import format
-            const normalized = {
-                id: playlist.playlistId,
-                name: playlist.name,
-                tracks: playlist.tracks.map(track => ({
-                    id: track.videoId,
-                    title: track.title,
-                    name: track.title,
-                    artists: track.artists.map(a => a.name),
-                    album: track.album?.name,
-                    duration: track.duration ?? 0,
-                })),
-                url: `https://www.youtube.com/playlist?list=${playlist.playlistId}`,
-            };
-            logger.info('YouTubeImportService', 'Successfully fetched playlist', {
-                playlistId,
-                trackCount: normalized.tracks.length,
-            });
-            return normalized;
-        }
-        catch (error) {
-            logger.error('YouTubeImportService', 'Failed to fetch playlist', {
-                playlistId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return null;
-        }
-    }
-    /**
-     * Validate if a playlist is accessible (not private/unavailable)
-     */
-    async validatePlaylist(urlOrId) {
-        const playlist = await this.fetchPlaylist(urlOrId);
-        return playlist !== null && playlist.tracks.length > 0;
-    }
-}
-// Singleton instance
-let youtubeImportServiceInstance = null;
-export function getYouTubeImportService() {
-    if (!youtubeImportServiceInstance) {
-        youtubeImportServiceInstance = new YouTubeImportService();
-    }
-    return youtubeImportServiceInstance;
-}

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

@@ -1,52 +0,0 @@
-// Debug logging service
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-const DEBUG_DIR = path.join(os.homedir(), '.youtube-music-cli');
-const DEBUG_FILE = path.join(DEBUG_DIR, 'debug.log');
-const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5MB
-// Ensure debug directory exists
-if (!fs.existsSync(DEBUG_DIR)) {
-    fs.mkdirSync(DEBUG_DIR, { recursive: true });
-}
-// Rotate log if too large
-if (fs.existsSync(DEBUG_FILE)) {
-    const stats = fs.statSync(DEBUG_FILE);
-    if (stats.size > MAX_LOG_SIZE) {
-        const backupFile = path.join(DEBUG_DIR, 'debug.log.old');
-        if (fs.existsSync(backupFile)) {
-            fs.unlinkSync(backupFile);
-        }
-        fs.renameSync(DEBUG_FILE, backupFile);
-    }
-}
-class Logger {
-    writeToFile(level, category, message, data) {
-        const timestamp = new Date().toISOString();
-        const dataStr = data ? `\n${JSON.stringify(data, null, 2)}` : '';
-        const logLine = `[${timestamp}] [${level}] [${category}] ${message}${dataStr}\n`;
-        fs.appendFileSync(DEBUG_FILE, logLine);
-    }
-    debug(category, message, data) {
-        this.writeToFile('DEBUG', category, message, data);
-    }
-    info(category, message, data) {
-        this.writeToFile('INFO', category, message, data);
-        // Disabled: console.log causes Ink to re-render constantly
-        // console.log(`[${category}] ${message}`);
-    }
-    warn(category, message, data) {
-        this.writeToFile('WARN', category, message, data);
-        // Disabled: console.warn causes Ink to re-render
-        // console.warn(`[${category}] ${message}`);
-    }
-    error(category, message, data) {
-        this.writeToFile('ERROR', category, message, data);
-        // Keep console.error for critical errors, but this should be rare
-        console.error(`[${category}] ${message}`);
-    }
-    getLogPath() {
-        return DEBUG_FILE;
-    }
-}
-export const logger = new Logger();

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

@@ -1,93 +0,0 @@
-// Lyrics service using LRCLIB API (https://lrclib.net)
-// Free, no authentication required
-import { logger } from "../logger/logger.service.js";
-const LRCLIB_BASE = 'https://lrclib.net/api';
-class LyricsService {
-    static instance;
-    cache = new Map();
-    constructor() { }
-    static getInstance() {
-        if (!LyricsService.instance) {
-            LyricsService.instance = new LyricsService();
-        }
-        return LyricsService.instance;
-    }
-    /** Parse LRC format into timed lines */
-    parseLrc(lrc) {
-        const lines = [];
-        const lineRegex = /\[(\d{2}):(\d{2})\.(\d{2,3})\](.*)/;
-        for (const rawLine of lrc.split('\n')) {
-            const match = lineRegex.exec(rawLine.trim());
-            if (match) {
-                const minutes = Number.parseInt(match[1], 10);
-                const seconds = Number.parseInt(match[2], 10);
-                const centiseconds = Number.parseInt(match[3].padEnd(3, '0'), 10);
-                const time = minutes * 60 + seconds + centiseconds / 1000;
-                const text = match[4].trim();
-                lines.push({ time, text });
-            }
-        }
-        return lines.sort((a, b) => a.time - b.time);
-    }
-    async getLyrics(trackName, artistName, duration) {
-        const cacheKey = `${trackName}::${artistName}`;
-        if (this.cache.has(cacheKey)) {
-            return this.cache.get(cacheKey) ?? null;
-        }
-        try {
-            const params = new URLSearchParams({
-                track_name: trackName,
-                artist_name: artistName,
-                ...(duration ? { duration: String(Math.round(duration)) } : {}),
-            });
-            const response = await fetch(`${LRCLIB_BASE}/get?${params.toString()}`);
-            if (!response.ok) {
-                if (response.status === 404) {
-                    logger.debug('LyricsService', 'No lyrics found', {
-                        trackName,
-                        artistName,
-                    });
-                    this.cache.set(cacheKey, null);
-                    return null;
-                }
-                throw new Error(`LRCLIB API error: ${response.status}`);
-            }
-            const data = (await response.json());
-            const lyrics = {
-                synced: data.syncedLyrics ? this.parseLrc(data.syncedLyrics) : null,
-                plain: data.plainLyrics ?? null,
-            };
-            this.cache.set(cacheKey, lyrics);
-            logger.info('LyricsService', 'Lyrics loaded', {
-                trackName,
-                hasSynced: !!lyrics.synced,
-                hasPlain: !!lyrics.plain,
-            });
-            return lyrics;
-        }
-        catch (error) {
-            logger.warn('LyricsService', 'Failed to fetch lyrics', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            this.cache.set(cacheKey, null);
-            return null;
-        }
-    }
-    /** Get the current lyric line index based on playback position */
-    getCurrentLineIndex(lines, currentTime) {
-        let index = 0;
-        for (let i = 0; i < lines.length; i++) {
-            if (lines[i].time <= currentTime) {
-                index = i;
-            }
-            else {
-                break;
-            }
-        }
-        return index;
-    }
-    clearCache() {
-        this.cache.clear();
-    }
-}
-export const getLyricsService = () => LyricsService.getInstance();

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

@@ -1,78 +0,0 @@
-// MPRIS service — Linux only, enables playerctl / media key support
-// No-ops on non-Linux platforms
-import { logger } from "../logger/logger.service.js";
-export class MprisService {
-    player = null;
-    get isSupported() {
-        return process.platform === 'linux';
-    }
-    async initialize(callbacks = {}) {
-        if (!this.isSupported) {
-            logger.debug('MprisService', 'MPRIS not supported on this platform', {
-                platform: process.platform,
-            });
-            return;
-        }
-        try {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            const mpris = (await import('mpris-service'));
-            this.player = mpris.createPlayer({
-                name: 'youtube-music-cli',
-                identity: 'YouTube Music CLI',
-                supportedInterfaces: ['player'],
-            });
-            // Wire up MPRIS events to player callbacks
-            if (callbacks.onPlay)
-                this.player.on('play', callbacks.onPlay);
-            if (callbacks.onPause)
-                this.player.on('pause', callbacks.onPause);
-            if (callbacks.onNext)
-                this.player.on('next', callbacks.onNext);
-            if (callbacks.onPrevious)
-                this.player.on('previous', callbacks.onPrevious);
-            this.player.canPlay = true;
-            this.player.canPause = true;
-            this.player.canGoNext = true;
-            this.player.canGoPrevious = true;
-            this.player.canSeek = false;
-            logger.info('MprisService', 'MPRIS player initialized');
-        }
-        catch (error) {
-            logger.warn('MprisService', 'Could not initialize MPRIS', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    updateTrack(track, isPlaying) {
-        if (!this.player)
-            return;
-        try {
-            this.player.metadata = {
-                'mpris:length': track.duration,
-                'xesam:title': track.title,
-                'xesam:artist': [track.artist],
-            };
-            this.player.playbackStatus = isPlaying ? 'Playing' : 'Paused';
-        }
-        catch {
-            // Ignore MPRIS update errors
-        }
-    }
-    setPlaying(playing) {
-        if (!this.player)
-            return;
-        try {
-            this.player.playbackStatus = playing ? 'Playing' : 'Paused';
-        }
-        catch {
-            // Ignore
-        }
-    }
-}
-let instance = null;
-export const getMprisService = () => {
-    if (!instance)
-        instance = new MprisService();
-    return instance;
-};

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

@@ -1,57 +0,0 @@
-// Desktop notification service
-import { logger } from "../logger/logger.service.js";
-class NotificationService {
-    static instance;
-    enabled = false;
-    notifier = null;
-    constructor() { }
-    static getInstance() {
-        if (!NotificationService.instance) {
-            NotificationService.instance = new NotificationService();
-        }
-        return NotificationService.instance;
-    }
-    setEnabled(enabled) {
-        this.enabled = enabled;
-    }
-    isEnabled() {
-        return this.enabled;
-    }
-    async getNotifier() {
-        if (!this.notifier) {
-            // Lazy-load to avoid startup cost when disabled
-            const mod = await import('node-notifier');
-            this.notifier = mod.default;
-        }
-        return this.notifier;
-    }
-    async notify(title, message) {
-        if (!this.enabled)
-            return;
-        try {
-            const notifier = await this.getNotifier();
-            notifier.notify({
-                title,
-                message,
-                sound: false,
-                wait: false,
-            }, (error) => {
-                if (error) {
-                    logger.warn('NotificationService', 'Notification failed', {
-                        error: error.message,
-                    });
-                }
-            });
-        }
-        catch (error) {
-            // Gracefully handle if notifications aren't supported
-            logger.warn('NotificationService', 'Failed to send notification', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async notifyTrackChange(title, artist) {
-        await this.notify('Now Playing', `${title} — ${artist}`);
-    }
-}
-export const getNotificationService = () => NotificationService.getInstance();