@involvex/youtube-music-cli 0.0.1 → 0.0.3

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

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

@@ -0,0 +1,20 @@
+interface TrackInfo {
+    title: string;
+    artist: string;
+    duration: number;
+}
+type PlaybackCallbacks = {
+    onPlay?: () => void;
+    onPause?: () => void;
+    onNext?: () => void;
+    onPrevious?: () => void;
+};
+export declare class MprisService {
+    private player;
+    get isSupported(): boolean;
+    initialize(callbacks?: PlaybackCallbacks): Promise<void>;
+    updateTrack(track: TrackInfo, isPlaying: boolean): void;
+    setPlaying(playing: boolean): void;
+}
+export declare const getMprisService: () => MprisService;
+export {};

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

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

@@ -0,0 +1,14 @@
+declare class NotificationService {
+    private static instance;
+    private enabled;
+    private notifier;
+    private constructor();
+    static getInstance(): NotificationService;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    private getNotifier;
+    notify(title: string, message: string): Promise<void>;
+    notifyTrackChange(title: string, artist: string): Promise<void>;
+}
+export declare const getNotificationService: () => NotificationService;
+export {};

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

@@ -0,0 +1,57 @@
+// 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();

package/dist/source/services/player/player.service.d.ts

@@ -1,5 +1,7 @@
 export type PlayOptions = {
     volume?: number;
+    audioNormalization?: boolean;
+    proxy?: string;
 };
 export type PlayerEventCallback = (event: {
     timePos?: number;
@@ -52,6 +54,7 @@ declare class PlayerService {
     stop(): void;
     setVolume(volume: number): void;
     getVolume(): number;
+    setSpeed(speed: number): void;
     isCurrentlyPlaying(): boolean;
 }
 export declare const getPlayerService: () => PlayerService;

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

@@ -203,7 +203,7 @@ class PlayerService {
                     ipcPath: this.ipcPath,
                 });
                 // Spawn mpv with JSON IPC for better control
-                this.mpvProcess = spawn('mpv', [
+                const mpvArgs = [
                     '--no-video', // Audio only
                     '--no-terminal', // Don't read from stdin
                     `--volume=${this.currentVolume}`,
@@ -212,8 +212,18 @@ class PlayerService {
                     '--msg-level=all=error', // Only show errors
                     `--input-ipc-server=${this.ipcPath}`, // Enable IPC
                     '--idle=yes', // Keep mpv running after playback ends
-                    playUrl,
-                ]);
+                    '--cache=yes', // Enable cache for network streams
+                    '--cache-secs=30', // Buffer 30 seconds ahead
+                    '--network-timeout=10', // 10s network timeout
+                ];
+                if (options?.audioNormalization) {
+                    mpvArgs.push('--af=dynaudnorm');
+                }
+                if (options?.proxy) {
+                    mpvArgs.push(`--http-proxy=${options.proxy}`);
+                }
+                mpvArgs.push(playUrl);
+                this.mpvProcess = spawn('mpv', mpvArgs);
                 if (!this.mpvProcess.stdout || !this.mpvProcess.stderr) {
                     throw new Error('Failed to create mpv process streams');
                 }
@@ -342,6 +352,13 @@ class PlayerService {
     getVolume() {
         return this.currentVolume;
     }
+    setSpeed(speed) {
+        const clamped = Math.max(0.25, Math.min(4.0, speed));
+        logger.debug('PlayerService', 'setSpeed() called', { speed: clamped });
+        if (this.ipcSocket && !this.ipcSocket.destroyed) {
+            this.sendIpcCommand(['set_property', 'speed', clamped]);
+        }
+    }
     isCurrentlyPlaying() {
         return this.isPlaying;
     }

package/dist/source/services/plugin/plugin-installer.service.js

@@ -111,7 +111,8 @@ class PluginInstallerService {
                     windowsHide: true,
                 });
             }
-            const pluginSourceDir = join(tempDir, 'plugins', pluginName);
+            // Plugin is at root of repo (e.g., adblock/, lyrics/, etc.)
+            const pluginSourceDir = join(tempDir, pluginName);
             if (!existsSync(pluginSourceDir)) {
                 rmSync(tempDir, { recursive: true, force: true });
                 return {

package/dist/source/services/scrobbling/scrobbling.service.d.ts

@@ -0,0 +1,23 @@
+interface TrackInfo {
+    title: string;
+    artist: string;
+    duration: number;
+}
+export declare class ScrobblingService {
+    private lastfmApiKey?;
+    private lastfmSessionKey?;
+    private listenbrainzToken?;
+    configure(config: {
+        lastfm?: {
+            apiKey?: string;
+            sessionKey?: string;
+        };
+        listenbrainz?: {
+            token?: string;
+        };
+    }): void;
+    get isEnabled(): boolean;
+    scrobble(track: TrackInfo): Promise<void>;
+}
+export declare const getScrobblingService: () => ScrobblingService;
+export {};

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

@@ -0,0 +1,115 @@
+// Scrobbling service — supports Last.fm and ListenBrainz
+import { createHash } from 'node:crypto';
+import { logger } from "../logger/logger.service.js";
+// ---------- Last.fm ----------
+async function lastfmScrobble(title, artist, timestamp, apiKey, sessionKey) {
+    const params = {
+        method: 'track.scrobble',
+        artist,
+        track: title,
+        timestamp: String(timestamp),
+        api_key: apiKey,
+        sk: sessionKey,
+    };
+    const secret = ''; // User must provide shared secret if using real auth
+    const sig = buildLastfmSignature(params, secret);
+    params['api_sig'] = sig;
+    params['format'] = 'json';
+    const body = new URLSearchParams(params);
+    const response = await fetch('https://ws.audioscrobbler.com/2.0/', {
+        method: 'POST',
+        body,
+    });
+    if (!response.ok) {
+        throw new Error(`Last.fm scrobble failed: HTTP ${response.status}`);
+    }
+    const data = (await response.json());
+    if (data.error) {
+        throw new Error(`Last.fm error ${data.error}: ${data.message}`);
+    }
+    logger.info('ScrobblingService', 'Last.fm scrobble successful', {
+        title,
+        artist,
+    });
+}
+function buildLastfmSignature(params, secret) {
+    const sorted = Object.keys(params)
+        .filter(k => k !== 'format' && k !== 'callback')
+        .sort()
+        .map(k => `${k}${params[k]}`)
+        .join('');
+    return createHash('md5')
+        .update(sorted + secret)
+        .digest('hex');
+}
+// ---------- ListenBrainz ----------
+async function listenbrainzScrobble(title, artist, listenedAt, token) {
+    const payload = {
+        listen_type: 'single',
+        payload: [
+            {
+                listened_at: listenedAt,
+                track_metadata: {
+                    artist_name: artist,
+                    track_name: title,
+                },
+            },
+        ],
+    };
+    const response = await fetch('https://api.listenbrainz.org/1/submit-listens', {
+        method: 'POST',
+        headers: {
+            Authorization: `Token ${token}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        throw new Error(`ListenBrainz scrobble failed: HTTP ${response.status}`);
+    }
+    logger.info('ScrobblingService', 'ListenBrainz scrobble successful', {
+        title,
+        artist,
+    });
+}
+// ---------- Main service ----------
+export class ScrobblingService {
+    lastfmApiKey;
+    lastfmSessionKey;
+    listenbrainzToken;
+    configure(config) {
+        this.lastfmApiKey = config.lastfm?.apiKey;
+        this.lastfmSessionKey = config.lastfm?.sessionKey;
+        this.listenbrainzToken = config.listenbrainz?.token;
+    }
+    get isEnabled() {
+        return Boolean((this.lastfmApiKey && this.lastfmSessionKey) || this.listenbrainzToken);
+    }
+    async scrobble(track) {
+        if (!this.isEnabled)
+            return;
+        const timestamp = Math.floor(Date.now() / 1000);
+        const tasks = [];
+        if (this.lastfmApiKey && this.lastfmSessionKey) {
+            tasks.push(lastfmScrobble(track.title, track.artist, timestamp, this.lastfmApiKey, this.lastfmSessionKey).catch(error => {
+                logger.error('ScrobblingService', 'Last.fm scrobble failed', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }));
+        }
+        if (this.listenbrainzToken) {
+            tasks.push(listenbrainzScrobble(track.title, track.artist, timestamp, this.listenbrainzToken).catch(error => {
+                logger.error('ScrobblingService', 'ListenBrainz scrobble failed', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }));
+        }
+        await Promise.all(tasks);
+    }
+}
+let instance = null;
+export const getScrobblingService = () => {
+    if (!instance)
+        instance = new ScrobblingService();
+    return instance;
+};

package/dist/source/services/sleep-timer/sleep-timer.service.d.ts

@@ -0,0 +1,16 @@
+export declare const SLEEP_TIMER_PRESETS: readonly [5, 10, 15, 30, 60];
+export type SleepTimerPreset = (typeof SLEEP_TIMER_PRESETS)[number];
+declare class SleepTimerService {
+    private static instance;
+    private timer;
+    private endTime;
+    private constructor();
+    static getInstance(): SleepTimerService;
+    start(minutes: number, onExpire: () => void): void;
+    cancel(): void;
+    /** Returns remaining seconds, or null if no timer active */
+    getRemainingSeconds(): number | null;
+    isActive(): boolean;
+}
+export declare const getSleepTimerService: () => SleepTimerService;
+export {};

package/dist/source/services/sleep-timer/sleep-timer.service.js

@@ -0,0 +1,45 @@
+// Sleep timer service - auto-stops playback after a set duration
+import { logger } from "../logger/logger.service.js";
+export const SLEEP_TIMER_PRESETS = [5, 10, 15, 30, 60];
+class SleepTimerService {
+    static instance;
+    timer = null;
+    endTime = null;
+    constructor() { }
+    static getInstance() {
+        if (!SleepTimerService.instance) {
+            SleepTimerService.instance = new SleepTimerService();
+        }
+        return SleepTimerService.instance;
+    }
+    start(minutes, onExpire) {
+        this.cancel();
+        this.endTime = Date.now() + minutes * 60 * 1000;
+        logger.info('SleepTimerService', 'Timer started', { minutes });
+        this.timer = setTimeout(() => {
+            logger.info('SleepTimerService', 'Timer expired');
+            this.endTime = null;
+            this.timer = null;
+            onExpire();
+        }, minutes * 60 * 1000);
+    }
+    cancel() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+            this.endTime = null;
+            logger.info('SleepTimerService', 'Timer cancelled');
+        }
+    }
+    /** Returns remaining seconds, or null if no timer active */
+    getRemainingSeconds() {
+        if (!this.endTime)
+            return null;
+        const remaining = Math.max(0, Math.ceil((this.endTime - Date.now()) / 1000));
+        return remaining;
+    }
+    isActive() {
+        return this.timer !== null;
+    }
+}
+export const getSleepTimerService = () => SleepTimerService.getInstance();

package/dist/source/services/youtube-music/api.d.ts

@@ -1,10 +1,16 @@
 import type { Track, Album, Artist, Playlist, SearchOptions, SearchResponse } from '../../types/youtube-music.types.ts';
 declare class MusicService {
+    private readonly searchCache;
     search(query: string, options?: SearchOptions): Promise<SearchResponse>;
     getTrack(videoId: string): Promise<Track | null>;
     getAlbum(albumId: string): Promise<Album>;
     getArtist(artistId: string): Promise<Artist>;
     getPlaylist(playlistId: string): Promise<Playlist>;
+    getTrending(): Promise<Track[]>;
+    getExploreSections(): Promise<Array<{
+        title: string;
+        tracks: Track[];
+    }>>;
     getSuggestions(trackId: string): Promise<Track[]>;
     getStreamUrl(videoId: string): Promise<string>;
     private getInvidiousStreamUrl;