@involvex/youtube-music-cli 0.0.2 → 0.0.3

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/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;

package/dist/source/services/youtube-music/api.js

@@ -1,5 +1,6 @@
 import { Innertube } from 'youtubei.js';
 import { logger } from "../logger/logger.service.js";
+import { getSearchCache } from "../cache/cache.service.js";
 // Initialize YouTube client
 let ytClient = null;
 async function getClient() {
@@ -9,9 +10,20 @@ async function getClient() {
     return ytClient;
 }
 class MusicService {
+    searchCache = getSearchCache();
     async search(query, options = {}) {
-        const results = [];
         const searchType = options.type || 'all';
+        const cacheKey = `search:${searchType}:${options.limit ?? 20}:${query}`;
+        // Return cached result if available
+        const cached = this.searchCache.get(cacheKey);
+        if (cached) {
+            logger.debug('MusicService', 'Returning cached search results', {
+                query,
+                resultCount: cached.results.length,
+            });
+            return cached;
+        }
+        const results = [];
         try {
             const yt = await getClient();
             const search = (await yt.search(query));
@@ -82,10 +94,13 @@ class MusicService {
         catch (error) {
             console.error('Search failed:', error);
         }
-        return {
+        const response = {
             results,
             hasMore: false,
         };
+        // Cache the result
+        this.searchCache.set(cacheKey, response);
+        return response;
     }
     async getTrack(videoId) {
         return {
@@ -115,6 +130,91 @@ class MusicService {
             tracks: [],
         };
     }
+    async getTrending() {
+        try {
+            const yt = await getClient();
+            const trending = (await yt.getTrending());
+            const tracks = [];
+            const sections = trending.sections ?? [];
+            for (const section of sections) {
+                for (const item of section.items ?? []) {
+                    const videoId = item.id || item.video_id;
+                    if (!videoId)
+                        continue;
+                    tracks.push({
+                        videoId,
+                        title: (typeof item.title === 'string'
+                            ? item.title
+                            : item.title?.text) ?? 'Unknown',
+                        artists: [
+                            {
+                                artistId: '',
+                                name: (typeof item.author === 'string'
+                                    ? item.author
+                                    : item.author?.name) ?? 'Unknown',
+                            },
+                        ],
+                        duration: (typeof item.duration === 'number'
+                            ? item.duration
+                            : item.duration?.seconds) ?? 0,
+                    });
+                }
+            }
+            return tracks.slice(0, 25);
+        }
+        catch (error) {
+            logger.error('MusicService', 'getTrending failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
+    async getExploreSections() {
+        try {
+            const yt = await getClient();
+            const music = yt.music;
+            const explore = (await music.getExplore());
+            const result = [];
+            for (const section of explore.sections ?? []) {
+                const title = (typeof section.header?.title === 'string'
+                    ? section.header.title
+                    : section.header?.title?.text) ?? 'Featured';
+                const tracks = [];
+                for (const item of section.contents ?? []) {
+                    const videoId = item.id || item.video_id;
+                    if (!videoId)
+                        continue;
+                    tracks.push({
+                        videoId,
+                        title: (typeof item.title === 'string'
+                            ? item.title
+                            : item.title?.text) ?? 'Unknown',
+                        artists: [
+                            {
+                                artistId: '',
+                                name: (typeof item.author === 'string'
+                                    ? item.author
+                                    : item.author?.name) ?? 'Unknown',
+                            },
+                        ],
+                        duration: (typeof item.duration === 'number'
+                            ? item.duration
+                            : item.duration?.seconds) ?? 0,
+                    });
+                }
+                if (tracks.length > 0) {
+                    result.push({ title, tracks: tracks.slice(0, 10) });
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            logger.error('MusicService', 'getExploreSections failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
     async getSuggestions(trackId) {
         try {
             const yt = await getClient();

package/dist/source/stores/navigation.store.js

@@ -11,6 +11,7 @@ const initialState = {
     hasSearched: false,
     searchLimit: 10,
     history: [],
+    playerMode: 'full',
 };
 function navigationReducer(state, action) {
     switch (action.category) {
@@ -48,6 +49,11 @@ function navigationReducer(state, action) {
                 ...state,
                 searchLimit: Math.max(1, Math.min(50, action.limit)),
             };
+        case 'TOGGLE_PLAYER_MODE':
+            return {
+                ...state,
+                playerMode: state.playerMode === 'full' ? 'mini' : 'full',
+            };
         default:
             return state;
     }

package/dist/source/stores/player.store.d.ts

@@ -13,6 +13,8 @@ type PlayerContextValue = {
     setVolume: (volume: number) => void;
     volumeUp: () => void;
     volumeDown: () => void;
+    volumeFineUp: () => void;
+    volumeFineDown: () => void;
     toggleShuffle: () => void;
     toggleRepeat: () => void;
     setQueue: (queue: Track[]) => void;
@@ -20,6 +22,9 @@ type PlayerContextValue = {
     removeFromQueue: (index: number) => void;
     clearQueue: () => void;
     setQueuePosition: (position: number) => void;
+    setSpeed: (speed: number) => void;
+    speedUp: () => void;
+    speedDown: () => void;
 };
 export declare function PlayerProvider({ children }: {
     children: ReactNode;