@involvex/youtube-music-cli 0.0.17 → 0.0.19

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

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

@@ -0,0 +1,17 @@
+import type { YouTubePlaylist } from '../../types/import.types.ts';
+declare class YouTubeImportService {
+    /**
+     * Extract playlist ID from various YouTube URL formats
+     */
+    extractPlaylistId(input: string): string | null;
+    /**
+     * Fetch a YouTube playlist and normalize to import format
+     */
+    fetchPlaylist(urlOrId: string): Promise<YouTubePlaylist | null>;
+    /**
+     * Validate if a playlist is accessible (not private/unavailable)
+     */
+    validatePlaylist(urlOrId: string): Promise<boolean>;
+}
+export declare function getYouTubeImportService(): YouTubeImportService;
+export {};

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

@@ -0,0 +1,84 @@
+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/web/static-file.service.d.ts

@@ -0,0 +1,31 @@
+declare class StaticFileService {
+    private webDistDir;
+    private indexHtml;
+    private indexHtmlLoaded;
+    constructor();
+    /**
+     * Get MIME type for a file extension
+     */
+    private getMimeType;
+    /**
+     * Load index.html into memory
+     */
+    private loadIndexHtml;
+    /**
+     * Serve a static file
+     */
+    serve(url: string, _req: unknown, res: {
+        writeHead: (statusCode: number, headers?: Record<string, string>) => void;
+        end: (data?: string | Buffer) => void;
+    }): Promise<void>;
+    /**
+     * Check if web UI is built
+     */
+    isWebUiBuilt(): boolean;
+    /**
+     * Clear cached index.html (useful for development)
+     */
+    clearCache(): void;
+}
+export declare function getStaticFileService(): StaticFileService;
+export {};

package/dist/source/services/web/static-file.service.js

@@ -0,0 +1,174 @@
+// Static file serving service for web UI
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { extname, join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { logger } from "../logger/logger.service.js";
+const MIME_TYPES = {
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'text/javascript',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.eot': 'application/vnd.ms-fontobject',
+};
+class StaticFileService {
+    webDistDir;
+    indexHtml = null;
+    indexHtmlLoaded = false;
+    constructor() {
+        // Web UI is built to dist/web/ relative to the project root
+        // Get the directory of the current file
+        const currentFile = fileURLToPath(import.meta.url);
+        const currentDir = dirname(currentFile);
+        // Detect if running from dist/ or source/
+        // dist/source/services/web -> need to go up 4 levels to reach project root
+        // source/services/web -> need to go up 3 levels to reach project root
+        const isDist = currentFile.includes('/dist/') || currentFile.includes('\\dist\\');
+        let projectRoot;
+        if (isDist) {
+            // dist/source/services/web -> services/web -> services -> source -> dist -> project root
+            projectRoot = join(currentDir, '..', '..', '..', '..');
+        }
+        else {
+            // source/services/web -> services/web -> services -> source -> project root
+            projectRoot = join(currentDir, '..', '..', '..');
+        }
+        this.webDistDir = join(projectRoot, 'dist', 'web');
+        console.log('[StaticFileService] Path resolution:', {
+            currentFile,
+            currentDir,
+            isDist,
+            projectRoot,
+            webDistDir: this.webDistDir,
+            exists: existsSync(this.webDistDir),
+        });
+    }
+    /**
+     * Get MIME type for a file extension
+     */
+    getMimeType(filePath) {
+        const ext = extname(filePath).toLowerCase();
+        return MIME_TYPES[ext] || 'application/octet-stream';
+    }
+    /**
+     * Load index.html into memory
+     */
+    async loadIndexHtml() {
+        if (this.indexHtmlLoaded)
+            return;
+        const indexPath = join(this.webDistDir, 'index.html');
+        console.log('[StaticFileService] Loading index.html:', {
+            webDistDir: this.webDistDir,
+            indexPath,
+            exists: existsSync(indexPath),
+        });
+        try {
+            const buffer = await readFile(indexPath);
+            this.indexHtml = buffer.toString('utf-8');
+            this.indexHtmlLoaded = true;
+            logger.debug('StaticFileService', 'index.html loaded', { indexPath });
+            console.log('[StaticFileService] index.html loaded successfully');
+        }
+        catch (error) {
+            console.error('[StaticFileService] Failed to load index.html:', error);
+            logger.error('StaticFileService', 'Failed to load index.html', {
+                indexPath,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Serve a static file
+     */
+    async serve(url, _req, res) {
+        // Remove query string
+        const urlPath = url.split('?')[0] ?? '/';
+        // Serve index.html for SPA routes
+        if (urlPath === '/' || !urlPath.includes('.')) {
+            // Ensure index.html is loaded
+            if (!this.indexHtmlLoaded) {
+                await this.loadIndexHtml();
+            }
+            if (this.indexHtml) {
+                res.writeHead(200, {
+                    'Content-Type': 'text/html',
+                    'Cache-Control': 'public, max-age=3600',
+                });
+                res.end(this.indexHtml);
+            }
+            else {
+                // Web UI not built, serve a simple message
+                res.writeHead(503, { 'Content-Type': 'text/html' });
+                res.end(`
+					<!DOCTYPE html>
+					<html>
+					<head><title>Web UI Not Built</title></head>
+					<body>
+						<h1>Web UI Not Built</h1>
+						<p>Run <code>bun run build:web</code> to build the web UI.</p>
+					</body>
+					</html>
+				`);
+            }
+            return;
+        }
+        // Serve static files
+        const filePath = join(this.webDistDir, urlPath);
+        try {
+            // Check if file exists
+            if (!existsSync(filePath)) {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('Not Found');
+                return;
+            }
+            // Read and serve file
+            const content = await readFile(filePath);
+            const mimeType = this.getMimeType(filePath);
+            res.writeHead(200, {
+                'Content-Type': mimeType,
+                'Cache-Control': 'public, max-age=86400', // 1 day
+            });
+            res.end(content);
+        }
+        catch (error) {
+            logger.error('StaticFileService', 'Failed to serve file', {
+                filePath,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            res.writeHead(500, { 'Content-Type': 'text/plain' });
+            res.end('Internal Server Error');
+        }
+    }
+    /**
+     * Check if web UI is built
+     */
+    isWebUiBuilt() {
+        const indexPath = join(this.webDistDir, 'index.html');
+        return existsSync(indexPath);
+    }
+    /**
+     * Clear cached index.html (useful for development)
+     */
+    clearCache() {
+        this.indexHtml = null;
+        this.indexHtmlLoaded = false;
+        logger.debug('StaticFileService', 'Cache cleared');
+    }
+}
+// Singleton instance
+let staticFileServiceInstance = null;
+export function getStaticFileService() {
+    if (!staticFileServiceInstance) {
+        staticFileServiceInstance = new StaticFileService();
+    }
+    return staticFileServiceInstance;
+}

package/dist/source/services/web/web-server-manager.d.ts

@@ -0,0 +1,66 @@
+import type { WebServerConfig, WebServerOptions } from '../../types/web.types.ts';
+import type { PlayerState } from '../../types/player.types.ts';
+declare class WebServerManager {
+    private config;
+    private isRunning;
+    private cleanupHooks;
+    constructor();
+    /**
+     * Start the web server
+     */
+    start(options?: WebServerOptions): Promise<void>;
+    /**
+     * Stop the web server
+     */
+    stop(): Promise<void>;
+    /**
+     * Set up player command handler
+     */
+    private setupCommandHandler;
+    /**
+     * Set up import progress handler
+     */
+    private setupImportHandler;
+    /**
+     * Handle command from web client
+     */
+    private handleCommand;
+    /**
+     * Handle import request from web client
+     */
+    private handleImportRequest;
+    /**
+     * Update player state (call this when player state changes)
+     */
+    updateState(state: PlayerState): void;
+    /**
+     * Set up graceful shutdown hooks
+     */
+    private setupShutdownHooks;
+    /**
+     * Check if server is running
+     */
+    isServerRunning(): boolean;
+    /**
+     * Get server URL
+     */
+    getServerUrl(): string;
+    /**
+     * Get server statistics
+     */
+    getStats(): {
+        running: boolean;
+        url?: string;
+        clients?: number;
+    };
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<WebServerConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): WebServerConfig;
+}
+export declare function getWebServerManager(): WebServerManager;
+export {};