@involvex/youtube-music-cli 0.0.47 → 0.0.48

package/dist/source/services/discord/discord-rpc.service.js

@@ -1,95 +0,0 @@
-// Discord Rich Presence service
-// Uses discord-rpc package if available; gracefully no-ops if Discord is not running
-import { logger } from "../logger/logger.service.js";
-export class DiscordRpcService {
-    client = null;
-    connected = false;
-    enabled = false;
-    setEnabled(enabled) {
-        this.enabled = enabled;
-        if (!enabled) {
-            void this.disconnect();
-        }
-    }
-    async connect() {
-        if (!this.enabled || this.connected)
-            return;
-        try {
-            // Dynamic import so missing package doesn't crash startup
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            const rpc = await import('discord-rpc');
-            const client = new rpc.Client({ transport: 'ipc' });
-            await new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => {
-                    reject(new Error('Discord RPC connection timeout'));
-                }, 5000);
-                client.on('ready', () => {
-                    clearTimeout(timeout);
-                    this.connected = true;
-                    logger.info('DiscordRpcService', 'Connected to Discord');
-                    resolve();
-                });
-                client
-                    .login({ clientId: '1473580336964177960' }) // Public client ID for music players
-                    .catch(reject);
-            });
-            this.client = client;
-        }
-        catch (error) {
-            logger.warn('DiscordRpcService', 'Could not connect to Discord', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async updateActivity(track) {
-        if (!this.enabled || !this.connected || !this.client)
-            return;
-        try {
-            const c = this.client;
-            await c.setActivity({
-                details: track.title,
-                state: `by ${track.artist}`,
-                startTimestamp: track.startTimestamp ?? Date.now(),
-                largeImageKey: 'logo',
-                largeImageText: 'YouTube Music CLI',
-                instance: false,
-            });
-        }
-        catch (error) {
-            logger.warn('DiscordRpcService', 'Failed to update Discord activity', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async clearActivity() {
-        if (!this.connected || !this.client)
-            return;
-        try {
-            const c = this.client;
-            await c.clearActivity();
-        }
-        catch {
-            // Ignore
-        }
-    }
-    async disconnect() {
-        if (!this.client)
-            return;
-        try {
-            const c = this.client;
-            await c.destroy();
-        }
-        catch {
-            // Ignore
-        }
-        this.client = null;
-        this.connected = false;
-    }
-}
-let instance = null;
-export const getDiscordRpcService = () => {
-    if (!instance)
-        instance = new DiscordRpcService();
-    return instance;
-};

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

@@ -1,350 +0,0 @@
-import { existsSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { getConfigService } from "../config/config.service.js";
-import { logger } from "../logger/logger.service.js";
-import { getMusicService } from "../youtube-music/api.js";
-class DownloadService {
-    ffmpegChecked = false;
-    ffmpegAvailable = false;
-    activeDownload = false;
-    config = getConfigService();
-    musicService = getMusicService();
-    getConfig() {
-        return {
-            enabled: this.config.get('downloadsEnabled') ?? false,
-            directory: this.config.get('downloadDirectory') ?? '',
-            format: (this.config.get('downloadFormat') ?? 'mp3'),
-        };
-    }
-    async resolveSearchTarget(result) {
-        if (result.type === 'song') {
-            const track = result.data;
-            return { name: track.title, tracks: [track] };
-        }
-        if (result.type === 'artist') {
-            const artistName = 'name' in result.data ? result.data.name : '';
-            if (!artistName) {
-                throw new Error('Artist name is missing.');
-            }
-            const response = await this.musicService.search(artistName, {
-                type: 'songs',
-                limit: 25,
-            });
-            const tracks = response.results
-                .filter(row => row.type === 'song')
-                .map(row => row.data);
-            return { name: artistName, tracks: this.uniqueTracks(tracks) };
-        }
-        if (result.type === 'playlist') {
-            const playlistInfo = result.data;
-            if (!playlistInfo.playlistId) {
-                throw new Error('Playlist id is missing.');
-            }
-            const playlist = await this.musicService.getPlaylist(playlistInfo.playlistId);
-            return {
-                name: playlist.name || playlistInfo.name || 'playlist',
-                tracks: this.uniqueTracks(playlist.tracks),
-            };
-        }
-        throw new Error('Downloads are supported for songs, artists, and playlists.');
-    }
-    resolvePlaylistTarget(playlist) {
-        return {
-            name: playlist.name,
-            tracks: this.uniqueTracks(playlist.tracks),
-        };
-    }
-    async downloadTracks(tracks) {
-        if (this.activeDownload) {
-            throw new Error('A download is already in progress. Please wait for it to finish.');
-        }
-        const { directory, format } = this.getConfig();
-        if (!directory) {
-            throw new Error('No download directory configured.');
-        }
-        mkdirSync(directory, { recursive: true });
-        await this.ensureFfmpeg();
-        this.activeDownload = true;
-        const result = {
-            downloaded: 0,
-            skipped: 0,
-            failed: 0,
-            errors: [],
-        };
-        try {
-            for (const track of tracks) {
-                const destination = this.getDestinationPath(track, directory, format);
-                const tempSource = `${destination}.source`;
-                const tempCover = `${destination}.cover.jpg`;
-                try {
-                    logger.info('DownloadService', 'Starting track download', {
-                        videoId: track.videoId,
-                        title: track.title,
-                    });
-                    mkdirSync(path.dirname(destination), { recursive: true });
-                    if (existsSync(destination)) {
-                        result.skipped++;
-                        logger.debug('DownloadService', 'Skipping existing file', {
-                            destination,
-                        });
-                        continue;
-                    }
-                    try {
-                        const streamUrl = await this.musicService.getStreamUrl(track.videoId);
-                        const audioBuffer = await this.fetchAudio(streamUrl);
-                        writeFileSync(tempSource, audioBuffer);
-                    }
-                    catch (streamError) {
-                        logger.warn('DownloadService', 'Stream URL extraction failed, falling back to yt-dlp', {
-                            videoId: track.videoId,
-                            error: streamError instanceof Error
-                                ? streamError.message
-                                : String(streamError),
-                        });
-                        try {
-                            await this.recordViaYtDlp(track.videoId, tempSource);
-                        }
-                        catch (ytdlpError) {
-                            logger.warn('DownloadService', 'yt-dlp fallback failed, falling back to mpv recording', {
-                                videoId: track.videoId,
-                                error: ytdlpError instanceof Error
-                                    ? ytdlpError.message
-                                    : String(ytdlpError),
-                            });
-                            await this.recordViaMpv(track.videoId, tempSource);
-                        }
-                    }
-                    const hasCover = await this.downloadCoverArt(track.videoId, tempCover);
-                    await this.convertAudio(tempSource, destination, format, track, hasCover ? tempCover : undefined);
-                    result.downloaded++;
-                    logger.info('DownloadService', 'Track download complete', {
-                        videoId: track.videoId,
-                        destination,
-                    });
-                }
-                catch (error) {
-                    result.failed++;
-                    const message = error instanceof Error ? error.message : 'Unknown download failure';
-                    result.errors.push(message);
-                    logger.error('DownloadService', 'Track download failed', {
-                        videoId: track.videoId,
-                        title: track.title,
-                        error: message,
-                    });
-                }
-                finally {
-                    if (existsSync(tempSource)) {
-                        unlinkSync(tempSource);
-                    }
-                    if (existsSync(tempCover)) {
-                        unlinkSync(tempCover);
-                    }
-                }
-            }
-            return result;
-        }
-        finally {
-            this.activeDownload = false;
-        }
-    }
-    uniqueTracks(tracks) {
-        const seen = new Set();
-        const unique = [];
-        for (const track of tracks) {
-            if (!track?.videoId || seen.has(track.videoId))
-                continue;
-            seen.add(track.videoId);
-            unique.push(track);
-        }
-        return unique;
-    }
-    getDestinationPath(track, directory, format) {
-        const artist = track.artists[0]?.name ?? 'Unknown Artist';
-        const album = track.album?.name ?? 'Singles';
-        const artistDir = this.sanitizeFilename(artist) || 'Unknown Artist';
-        const albumDir = this.sanitizeFilename(album) || 'Singles';
-        const fileName = this.sanitizeFilename(track.title) || track.videoId;
-        return path.join(directory, artistDir, albumDir, `${fileName}.${format}`);
-    }
-    sanitizeFilename(value) {
-        return value.replace(/[<>:"/\\|?*\u0000-\u001F]/g, '_').trim();
-    }
-    async fetchAudio(url) {
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch audio stream (${response.status}).`);
-        }
-        const audio = await response.arrayBuffer();
-        return Buffer.from(audio);
-    }
-    async ensureFfmpeg() {
-        if (this.ffmpegChecked) {
-            if (!this.ffmpegAvailable) {
-                throw new Error('ffmpeg is required for downloads. Install ffmpeg and ensure it is available in PATH.');
-            }
-            return;
-        }
-        this.ffmpegChecked = true;
-        try {
-            await this.runFfmpeg(['-version']);
-            this.ffmpegAvailable = true;
-        }
-        catch {
-            this.ffmpegAvailable = false;
-            throw new Error('ffmpeg is required for downloads. Install ffmpeg and ensure it is available in PATH.');
-        }
-    }
-    async convertAudio(sourcePath, destinationPath, format, track, coverPath) {
-        const metadataArgs = this.buildMetadataArgs(track);
-        if (format === 'mp3') {
-            const args = ['-y', '-i', sourcePath];
-            if (coverPath) {
-                args.push('-i', coverPath, '-map', '0:a:0', '-map', '1:v:0');
-            }
-            else {
-                args.push('-map', '0:a:0', '-vn');
-            }
-            args.push('-codec:a', 'libmp3lame', '-q:a', '2', ...metadataArgs);
-            if (coverPath) {
-                args.push('-codec:v', 'mjpeg', '-disposition:v:0', 'attached_pic', '-metadata:s:v', 'title=Album cover', '-metadata:s:v', 'comment=Cover (front)');
-            }
-            args.push(destinationPath);
-            await this.runFfmpeg(args);
-            return;
-        }
-        const args = ['-y', '-i', sourcePath];
-        if (coverPath) {
-            args.push('-i', coverPath, '-map', '0:a:0', '-map', '1:v:0');
-        }
-        else {
-            args.push('-map', '0:a:0', '-vn');
-        }
-        args.push('-codec:a', 'aac', '-b:a', '192k', ...metadataArgs);
-        if (coverPath) {
-            args.push('-codec:v', 'mjpeg', '-disposition:v:0', 'attached_pic');
-        }
-        args.push(destinationPath);
-        await this.runFfmpeg(args);
-    }
-    buildMetadataArgs(track) {
-        const artist = track.artists
-            .map(row => row.name)
-            .filter(Boolean)
-            .join(', ') || 'Unknown Artist';
-        const album = track.album?.name || 'Singles';
-        return [
-            '-metadata',
-            `title=${track.title}`,
-            '-metadata',
-            `artist=${artist}`,
-            '-metadata',
-            `album=${album}`,
-        ];
-    }
-    async runFfmpeg(args) {
-        await new Promise((resolve, reject) => {
-            const process = spawn('ffmpeg', args, { windowsHide: true });
-            let stderr = '';
-            process.stderr.on('data', chunk => {
-                stderr += String(chunk);
-            });
-            process.on('error', reject);
-            process.on('exit', code => {
-                if (code === 0) {
-                    resolve();
-                    return;
-                }
-                reject(new Error(stderr.trim() || `ffmpeg exited with code ${code}`));
-            });
-        });
-    }
-    async recordViaYtDlp(videoId, outputPath) {
-        const watchUrl = `https://www.youtube.com/watch?v=${videoId}`;
-        await new Promise((resolve, reject) => {
-            const process = spawn('yt-dlp', [
-                '--no-playlist',
-                '--quiet',
-                '--no-warnings',
-                '--js-runtimes',
-                'node',
-                '-f',
-                'bestaudio',
-                '--output',
-                outputPath,
-                watchUrl,
-            ], { windowsHide: true });
-            let stderr = '';
-            let stdout = '';
-            process.stderr.on('data', chunk => {
-                stderr += String(chunk);
-            });
-            process.stdout.on('data', chunk => {
-                stdout += String(chunk);
-            });
-            process.on('error', reject);
-            process.on('exit', code => {
-                if (code === 0 && existsSync(outputPath)) {
-                    resolve();
-                    return;
-                }
-                reject(new Error((stderr || stdout).trim() ||
-                    `yt-dlp exited with code ${code} and no output file`));
-            });
-        });
-    }
-    async downloadCoverArt(videoId, outputPath) {
-        const candidates = [
-            `https://i.ytimg.com/vi/${videoId}/maxresdefault.jpg`,
-            `https://i.ytimg.com/vi/${videoId}/hqdefault.jpg`,
-        ];
-        for (const url of candidates) {
-            try {
-                const response = await fetch(url);
-                if (!response.ok)
-                    continue;
-                const image = Buffer.from(await response.arrayBuffer());
-                if (image.length === 0)
-                    continue;
-                writeFileSync(outputPath, image);
-                return true;
-            }
-            catch {
-                continue;
-            }
-        }
-        return false;
-    }
-    async recordViaMpv(videoId, outputPath) {
-        const watchUrl = `https://www.youtube.com/watch?v=${videoId}`;
-        await new Promise((resolve, reject) => {
-            const process = spawn('mpv', [
-                watchUrl,
-                '--no-video',
-                '--ao=null',
-                '--ytdl=yes',
-                '--really-quiet',
-                `--stream-record=${outputPath}`,
-            ], { windowsHide: true });
-            let stderr = '';
-            process.stderr.on('data', chunk => {
-                stderr += String(chunk);
-            });
-            process.on('error', reject);
-            process.on('exit', code => {
-                if (code === 0 && existsSync(outputPath)) {
-                    resolve();
-                    return;
-                }
-                reject(new Error(stderr.trim() || `mpv exited with code ${code} and no output file`));
-            });
-        });
-    }
-}
-let downloadServiceInstance = null;
-export function getDownloadService() {
-    if (!downloadServiceInstance) {
-        downloadServiceInstance = new DownloadService();
-    }
-    return downloadServiceInstance;
-}

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

@@ -1,131 +0,0 @@
-// Playlist export service for JSON and M3U8 formats
-import { mkdirSync, writeFileSync, existsSync } from 'node:fs';
-import { CONFIG_DIR } from "../../utils/constants.js";
-import { logger } from "../logger/logger.service.js";
-class ExportService {
-    static instance;
-    DEFAULT_EXPORT_DIR = `${CONFIG_DIR}/exports`;
-    constructor() { }
-    static getInstance() {
-        if (!ExportService.instance) {
-            ExportService.instance = new ExportService();
-        }
-        return ExportService.instance;
-    }
-    /**
-     * Get the export directory, create if it doesn't exist
-     */
-    getExportDir(customDir) {
-        const exportDir = customDir || this.DEFAULT_EXPORT_DIR;
-        if (!existsSync(exportDir)) {
-            try {
-                mkdirSync(exportDir, { recursive: true });
-                logger.info('ExportService', 'Created export directory', { exportDir });
-            }
-            catch (error) {
-                logger.error('ExportService', 'Failed to create export directory', {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                throw new Error(`Failed to create export directory: ${exportDir}`);
-            }
-        }
-        return exportDir;
-    }
-    /**
-     * Sanitize filename for safe file system usage
-     */
-    sanitizeFilename(name) {
-        // Remove or replace characters that are unsafe for filenames
-        return name
-            .replace(/[<>:"/\\|?*]/g, '') // Remove unsafe chars
-            .replace(/\s+/g, '_') // Replace spaces with underscores
-            .substring(0, 200); // Limit length
-    }
-    /**
-     * Generate M3U8 format content for a playlist
-     */
-    generateM3U8(playlist) {
-        const lines = ['#EXTM3U', ''];
-        for (const track of playlist.tracks) {
-            if (track.artists && track.artists.length > 0) {
-                const artistNames = track.artists.map(a => a.name).join(', ');
-                const duration = track.duration
-                    ? Math.round(track.duration / 1000)
-                    : -1;
-                lines.push(`#EXTINF:${duration},${artistNames} - ${track.title}`);
-            }
-            else {
-                lines.push(`#EXTINF:-1,${track.title}`);
-            }
-            // Use the videoId to generate YouTube URL
-            if (track.videoId) {
-                lines.push(`https://www.youtube.com/watch?v=${track.videoId}`);
-            }
-        }
-        return lines.join('\n');
-    }
-    /**
-     * Export a single playlist to the specified format(s)
-     */
-    async exportPlaylist(playlist, options) {
-        try {
-            logger.info('ExportService', 'Exporting playlist', {
-                playlist: playlist.name,
-                format: options.format,
-            });
-            const exportDir = this.getExportDir(options.outputDir);
-            const sanitizedName = this.sanitizeFilename(playlist.name);
-            const files = [];
-            // Export to JSON
-            if (options.format === 'json' || options.format === 'both') {
-                const jsonPath = `${exportDir}/${sanitizedName}.json`;
-                const jsonContent = JSON.stringify(playlist, null, 2);
-                writeFileSync(jsonPath, jsonContent, 'utf-8');
-                files.push(jsonPath);
-                logger.info('ExportService', 'Exported to JSON', { path: jsonPath });
-            }
-            // Export to M3U8
-            if (options.format === 'm3u8' || options.format === 'both') {
-                const m3u8Path = `${exportDir}/${sanitizedName}.m3u8`;
-                const m3u8Content = this.generateM3U8(playlist);
-                writeFileSync(m3u8Path, m3u8Content, 'utf-8');
-                files.push(m3u8Path);
-                logger.info('ExportService', 'Exported to M3U8', { path: m3u8Path });
-            }
-            return {
-                playlistName: playlist.name,
-                format: options.format,
-                files,
-                success: true,
-            };
-        }
-        catch (error) {
-            logger.error('ExportService', 'Failed to export playlist', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                playlistName: playlist.name,
-                format: options.format,
-                files: [],
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    /**
-     * Export multiple playlists to the specified format(s)
-     */
-    async exportAllPlaylists(playlists, options) {
-        logger.info('ExportService', 'Exporting all playlists', {
-            count: playlists.length,
-            format: options.format,
-        });
-        const results = [];
-        for (const playlist of playlists) {
-            const result = await this.exportPlaylist(playlist, options);
-            results.push(result);
-        }
-        return results;
-    }
-}
-export const getExportService = () => ExportService.getInstance();

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

@@ -1,83 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { CONFIG_DIR } from "../../utils/constants.js";
-import { logger } from "../logger/logger.service.js";
-const HISTORY_FILE = join(CONFIG_DIR, 'history.json');
-const SCHEMA_VERSION = 1;
-const defaultHistory = {
-    schemaVersion: SCHEMA_VERSION,
-    entries: [],
-    lastUpdated: new Date().toISOString(),
-};
-export async function saveHistory(entries) {
-    try {
-        if (!existsSync(CONFIG_DIR)) {
-            await mkdir(CONFIG_DIR, { recursive: true });
-        }
-        const stateToSave = {
-            ...defaultHistory,
-            entries,
-            lastUpdated: new Date().toISOString(),
-        };
-        const tempFile = `${HISTORY_FILE}.tmp`;
-        await writeFile(tempFile, JSON.stringify(stateToSave, null, 2), 'utf8');
-        if (process.platform === 'win32' && existsSync(HISTORY_FILE)) {
-            await import('node:fs/promises').then(fs => fs.unlink(HISTORY_FILE));
-        }
-        await import('node:fs/promises').then(fs => fs.rename(tempFile, HISTORY_FILE));
-        logger.debug('HistoryService', 'Saved listening history', {
-            count: entries.length,
-        });
-    }
-    catch (error) {
-        logger.error('HistoryService', 'Failed to save listening history', {
-            error: error instanceof Error ? error.message : String(error),
-        });
-    }
-}
-export async function loadHistory() {
-    try {
-        if (!existsSync(HISTORY_FILE)) {
-            logger.debug('HistoryService', 'No history file found');
-            return [];
-        }
-        const data = await readFile(HISTORY_FILE, 'utf8');
-        const persisted = JSON.parse(data);
-        if (persisted.schemaVersion !== SCHEMA_VERSION) {
-            logger.warn('HistoryService', 'Schema version mismatch', {
-                expected: SCHEMA_VERSION,
-                found: persisted.schemaVersion,
-            });
-            return [];
-        }
-        if (!Array.isArray(persisted.entries)) {
-            logger.warn('HistoryService', 'Invalid history format, resetting');
-            return [];
-        }
-        logger.info('HistoryService', 'Loaded listening history', {
-            count: persisted.entries.length,
-            lastUpdated: persisted.lastUpdated,
-        });
-        return persisted.entries;
-    }
-    catch (error) {
-        logger.error('HistoryService', 'Failed to load listening history', {
-            error: error instanceof Error ? error.message : String(error),
-        });
-        return [];
-    }
-}
-export async function clearHistory() {
-    try {
-        if (existsSync(HISTORY_FILE)) {
-            await import('node:fs/promises').then(fs => fs.unlink(HISTORY_FILE));
-            logger.info('HistoryService', 'Cleared listening history');
-        }
-    }
-    catch (error) {
-        logger.error('HistoryService', 'Failed to clear listening history', {
-            error: error instanceof Error ? error.message : String(error),
-        });
-    }
-}