@involvex/youtube-music-cli 0.0.2 → 0.0.3

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

@@ -4,10 +4,15 @@ import { createContext, useContext, useReducer, useEffect, useRef, } from 'react
 import { getPlayerService } from "../services/player/player.service.js";
 import { loadPlayerState, savePlayerState, } from "../services/player-state/player-state.service.js";
 import { logger } from "../services/logger/logger.service.js";
+import { getNotificationService } from "../services/notification/notification.service.js";
+import { getScrobblingService } from "../services/scrobbling/scrobbling.service.js";
+import { getDiscordRpcService } from "../services/discord/discord-rpc.service.js";
+import { getMprisService } from "../services/mpris/mpris.service.js";
 const initialState = {
     currentTrack: null,
     isPlaying: false,
     volume: 70,
+    speed: 1.0,
     progress: 0,
     duration: 0,
     queue: [],
@@ -104,6 +109,16 @@ function playerReducer(state, action) {
             playerService.setVolume(newVolume);
             return { ...state, volume: newVolume };
         }
+        case 'VOLUME_FINE_UP': {
+            const newVolume = Math.min(100, state.volume + 1);
+            playerService.setVolume(newVolume);
+            return { ...state, volume: newVolume };
+        }
+        case 'VOLUME_FINE_DOWN': {
+            const newVolume = Math.max(0, state.volume - 1);
+            playerService.setVolume(newVolume);
+            return { ...state, volume: newVolume };
+        }
         case 'TOGGLE_SHUFFLE':
             return { ...state, shuffle: !state.shuffle };
         case 'TOGGLE_REPEAT':
@@ -160,6 +175,11 @@ function playerReducer(state, action) {
             return { ...state, isLoading: action.loading };
         case 'SET_ERROR':
             return { ...state, error: action.error, isLoading: false };
+        case 'SET_SPEED': {
+            const clampedSpeed = Math.max(0.25, Math.min(4.0, action.speed));
+            playerService.setSpeed(clampedSpeed);
+            return { ...state, speed: clampedSpeed };
+        }
         case 'RESTORE_STATE':
             logger.info('PlayerReducer', 'RESTORE_STATE', {
                 hasTrack: !!action.currentTrack,
@@ -189,6 +209,15 @@ function PlayerManager() {
     const progressIntervalRef = useRef(null);
     const musicService = getMusicService();
     const playerService = getPlayerService();
+    // Initialize MPRIS (Linux only, no-ops on other platforms)
+    useEffect(() => {
+        void getMprisService().initialize({
+            onPlay: () => dispatch({ category: 'RESUME' }),
+            onPause: () => dispatch({ category: 'PAUSE' }),
+            onNext: () => dispatch({ category: 'NEXT' }),
+            onPrevious: () => dispatch({ category: 'PREVIOUS' }),
+        });
+    }, [dispatch]);
     // Register event handler for mpv IPC events
     useEffect(() => {
         let lastProgressUpdate = 0;
@@ -260,29 +289,76 @@ function PlayerManager() {
         });
         const loadAndPlayTrack = async () => {
             dispatch({ category: 'SET_LOADING', loading: true });
-            try {
-                logger.debug('PlayerManager', 'Starting playback with mpv', {
-                    videoId: track.videoId,
-                    volume: state.volume,
-                });
-                // Pass YouTube URL directly to mpv (it handles stream extraction via yt-dlp)
-                const youtubeUrl = `https://www.youtube.com/watch?v=${track.videoId}`;
-                await playerService.play(youtubeUrl, {
-                    volume: state.volume,
-                });
-                logger.info('PlayerManager', 'Playback started successfully');
-                dispatch({ category: 'SET_LOADING', loading: false });
-            }
-            catch (error) {
-                logger.error('PlayerManager', 'Failed to load track', {
-                    error: error instanceof Error ? error.message : String(error),
-                    stack: error instanceof Error ? error.stack : undefined,
-                    track: { title: track.title, videoId: track.videoId },
-                });
-                dispatch({
-                    category: 'SET_ERROR',
-                    error: error instanceof Error ? error.message : 'Failed to load track',
-                });
+            const MAX_RETRIES = 3;
+            const RETRY_DELAY_MS = 1500;
+            for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+                try {
+                    logger.debug('PlayerManager', 'Starting playback with mpv', {
+                        videoId: track.videoId,
+                        volume: state.volume,
+                        attempt,
+                    });
+                    // Pass YouTube URL directly to mpv (it handles stream extraction via yt-dlp)
+                    const youtubeUrl = `https://www.youtube.com/watch?v=${track.videoId}`;
+                    const config = getConfigService();
+                    const artists = track.artists?.map(a => a.name).join(', ') ?? 'Unknown';
+                    // Fire desktop notification if enabled (only on first attempt)
+                    if (attempt === 1 && config.get('notifications')) {
+                        const notificationService = getNotificationService();
+                        notificationService.setEnabled(true);
+                        void notificationService.notifyTrackChange(track.title, artists);
+                    }
+                    // Discord Rich Presence
+                    if (config.get('discordRichPresence')) {
+                        const discord = getDiscordRpcService();
+                        discord.setEnabled(true);
+                        void discord.connect().then(() => discord.updateActivity({
+                            title: track.title,
+                            artist: artists,
+                            startTimestamp: Date.now(),
+                        }));
+                    }
+                    // MPRIS (Linux)
+                    const mpris = getMprisService();
+                    mpris.updateTrack({
+                        title: track.title,
+                        artist: artists,
+                        duration: (track.duration ?? 0) * 1_000_000,
+                    }, true);
+                    await playerService.play(youtubeUrl, {
+                        volume: state.volume,
+                        audioNormalization: config.get('audioNormalization') ?? false,
+                        proxy: config.get('proxy'),
+                    });
+                    logger.info('PlayerManager', 'Playback started successfully', {
+                        attempt,
+                    });
+                    dispatch({ category: 'SET_LOADING', loading: false });
+                    return; // Success
+                }
+                catch (error) {
+                    logger.error('PlayerManager', 'Failed to load track', {
+                        error: error instanceof Error ? error.message : String(error),
+                        track: { title: track.title, videoId: track.videoId },
+                        attempt,
+                    });
+                    if (attempt < MAX_RETRIES) {
+                        logger.info('PlayerManager', 'Retrying playback', {
+                            attempt,
+                            nextAttempt: attempt + 1,
+                            delayMs: RETRY_DELAY_MS,
+                        });
+                        await new Promise(resolve => setTimeout(resolve, RETRY_DELAY_MS));
+                    }
+                    else {
+                        dispatch({
+                            category: 'SET_ERROR',
+                            error: error instanceof Error
+                                ? `${error.message} (after ${MAX_RETRIES} attempts)`
+                                : 'Failed to load track',
+                        });
+                    }
+                }
             }
         };
         void loadAndPlayTrack();
@@ -301,6 +377,34 @@ function PlayerManager() {
         }
         return undefined;
     }, [state.isPlaying, state.currentTrack, dispatch]);
+    // Scrobble when >50% of track has been played
+    const scrobbledRef = useRef(null);
+    useEffect(() => {
+        if (state.currentTrack &&
+            state.duration > 0 &&
+            state.progress / state.duration > 0.5 &&
+            scrobbledRef.current !== state.currentTrack.videoId) {
+            scrobbledRef.current = state.currentTrack.videoId;
+            const config = getConfigService();
+            const scrobblingConfig = config.get('scrobbling');
+            if (scrobblingConfig) {
+                const scrobbler = getScrobblingService();
+                scrobbler.configure(scrobblingConfig);
+                const artist = state.currentTrack.artists?.[0]?.name ?? 'Unknown';
+                void scrobbler.scrobble({
+                    title: state.currentTrack.title,
+                    artist,
+                    duration: state.duration,
+                });
+            }
+        }
+        if (state.currentTrack &&
+            scrobbledRef.current !== state.currentTrack.videoId &&
+            state.progress < 1) {
+            // New track started — reset so we can scrobble again
+            scrobbledRef.current = null;
+        }
+    }, [state.progress, state.duration, state.currentTrack]);
     // Handle play/pause state
     useEffect(() => {
         if (!state.isPlaying) {
@@ -441,6 +545,12 @@ export function PlayerProvider({ children }) {
             logger.debug('PlayerActions', 'volumeDown called');
             dispatch({ category: 'VOLUME_DOWN' });
         },
+        volumeFineUp: () => {
+            dispatch({ category: 'VOLUME_FINE_UP' });
+        },
+        volumeFineDown: () => {
+            dispatch({ category: 'VOLUME_FINE_DOWN' });
+        },
         toggleShuffle: () => dispatch({ category: 'TOGGLE_SHUFFLE' }),
         toggleRepeat: () => dispatch({ category: 'TOGGLE_REPEAT' }),
         setQueue: (queue) => dispatch({ category: 'SET_QUEUE', queue }),
@@ -448,7 +558,14 @@ export function PlayerProvider({ children }) {
         removeFromQueue: (index) => dispatch({ category: 'REMOVE_FROM_QUEUE', index }),
         clearQueue: () => dispatch({ category: 'CLEAR_QUEUE' }),
         setQueuePosition: (position) => dispatch({ category: 'SET_QUEUE_POSITION', position }),
-    }), [dispatch]);
+        setSpeed: (speed) => dispatch({ category: 'SET_SPEED', speed }),
+        speedUp: () => {
+            dispatch({ category: 'SET_SPEED', speed: (state.speed ?? 1.0) + 0.25 });
+        },
+        speedDown: () => {
+            dispatch({ category: 'SET_SPEED', speed: (state.speed ?? 1.0) - 0.25 });
+        },
+    }), [dispatch, state.speed]);
     const contextValue = useMemo(() => ({
         state,
         dispatch, // Needed by PlayerManager

package/dist/source/types/actions.d.ts

@@ -32,6 +32,12 @@ export interface VolumeUpAction {
 export interface VolumeDownAction {
     readonly category: 'VOLUME_DOWN';
 }
+export interface VolumeFineUpAction {
+    readonly category: 'VOLUME_FINE_UP';
+}
+export interface VolumeFineDownAction {
+    readonly category: 'VOLUME_FINE_DOWN';
+}
 export interface ToggleShuffleAction {
     readonly category: 'TOGGLE_SHUFFLE';
 }
@@ -86,6 +92,10 @@ export interface RestoreStateAction {
     shuffle: boolean;
     repeat: 'off' | 'all' | 'one';
 }
+export interface SetSpeedAction {
+    readonly category: 'SET_SPEED';
+    speed: number;
+}
 export interface NavigateAction {
     readonly category: 'NAVIGATE';
     view: string;
@@ -117,3 +127,6 @@ export interface SetSearchLimitAction {
     readonly category: 'SET_SEARCH_LIMIT';
     limit: number;
 }
+export interface TogglePlayerModeAction {
+    readonly category: 'TOGGLE_PLAYER_MODE';
+}

package/dist/source/types/config.types.d.ts

@@ -6,14 +6,28 @@ export interface KeybindingConfig {
     description: string;
 }
 export interface Config {
-    theme: 'dark' | 'light' | 'midnight' | 'matrix' | 'custom';
+    theme: 'dark' | 'light' | 'midnight' | 'matrix' | 'dracula' | 'nord' | 'solarized' | 'catppuccin' | 'custom';
     volume: number;
     keybindings: Record<string, KeybindingConfig>;
     playlists: Playlist[];
     history: string[];
+    searchHistory: string[];
     favorites: string[];
     repeat: RepeatMode;
     shuffle: boolean;
     customTheme?: Theme;
     streamQuality?: 'low' | 'medium' | 'high';
+    audioNormalization?: boolean;
+    notifications?: boolean;
+    scrobbling?: {
+        lastfm?: {
+            apiKey?: string;
+            sessionKey?: string;
+        };
+        listenbrainz?: {
+            token?: string;
+        };
+    };
+    discordRichPresence?: boolean;
+    proxy?: string;
 }

package/dist/source/types/navigation.types.d.ts

@@ -1,4 +1,4 @@
-import type { NavigateAction, GoBackAction, SetSearchQueryAction, SetSearchCategoryAction, SetSelectedResultAction, SetSelectedPlaylistAction, SetHasSearchedAction, SetSearchLimitAction } from './actions.ts';
+import type { NavigateAction, GoBackAction, SetSearchQueryAction, SetSearchCategoryAction, SetSelectedResultAction, SetSelectedPlaylistAction, SetHasSearchedAction, SetSearchLimitAction, TogglePlayerModeAction } from './actions.ts';
 export interface NavigationState {
     currentView: string;
     previousView: string | null;
@@ -10,5 +10,6 @@ export interface NavigationState {
     hasSearched: boolean;
     searchLimit: number;
     history: string[];
+    playerMode: 'full' | 'mini';
 }
-export type NavigationAction = NavigateAction | GoBackAction | SetSearchQueryAction | SetSearchCategoryAction | SetSelectedResultAction | SetSelectedPlaylistAction | SetHasSearchedAction | SetSearchLimitAction;
+export type NavigationAction = NavigateAction | GoBackAction | SetSearchQueryAction | SetSearchCategoryAction | SetSelectedResultAction | SetSelectedPlaylistAction | SetHasSearchedAction | SetSearchLimitAction | TogglePlayerModeAction;

package/dist/source/types/player.types.d.ts

@@ -1,9 +1,10 @@
-import type { PlayAction, PauseAction, ResumeAction, StopAction, NextAction, PreviousAction, SeekAction, SetVolumeAction, VolumeUpAction, VolumeDownAction, ToggleShuffleAction, ToggleRepeatAction, SetQueueAction, AddToQueueAction, RemoveFromQueueAction, ClearQueueAction, SetQueuePositionAction, UpdateProgressAction, SetDurationAction, TickAction, SetLoadingAction, SetErrorAction, RestoreStateAction } from './actions.ts';
+import type { PlayAction, PauseAction, ResumeAction, StopAction, NextAction, PreviousAction, SeekAction, SetVolumeAction, VolumeUpAction, VolumeDownAction, VolumeFineUpAction, VolumeFineDownAction, ToggleShuffleAction, ToggleRepeatAction, SetQueueAction, AddToQueueAction, RemoveFromQueueAction, ClearQueueAction, SetQueuePositionAction, UpdateProgressAction, SetDurationAction, TickAction, SetLoadingAction, SetErrorAction, RestoreStateAction, SetSpeedAction } from './actions.ts';
 import type { Track } from './youtube-music.types.ts';
 export interface PlayerState {
     currentTrack: Track | null;
     isPlaying: boolean;
     volume: number;
+    speed: number;
     progress: number;
     duration: number;
     queue: Track[];
@@ -13,4 +14,4 @@ export interface PlayerState {
     isLoading: boolean;
     error: string | null;
 }
-export type PlayerAction = PlayAction | PauseAction | ResumeAction | StopAction | NextAction | PreviousAction | SeekAction | SetVolumeAction | VolumeUpAction | VolumeDownAction | ToggleShuffleAction | ToggleRepeatAction | SetQueueAction | AddToQueueAction | RemoveFromQueueAction | ClearQueueAction | SetQueuePositionAction | UpdateProgressAction | SetDurationAction | TickAction | SetLoadingAction | SetErrorAction | RestoreStateAction;
+export type PlayerAction = PlayAction | PauseAction | ResumeAction | StopAction | NextAction | PreviousAction | SeekAction | SetVolumeAction | VolumeUpAction | VolumeDownAction | VolumeFineUpAction | VolumeFineDownAction | ToggleShuffleAction | ToggleRepeatAction | SetQueueAction | AddToQueueAction | RemoveFromQueueAction | ClearQueueAction | SetQueuePositionAction | UpdateProgressAction | SetDurationAction | TickAction | SetLoadingAction | SetErrorAction | RestoreStateAction | SetSpeedAction;

package/dist/source/utils/constants.d.ts

@@ -5,6 +5,7 @@ export declare const CONFIG_FILE: string;
 export declare const VIEW: {
     readonly PLAYER: "player";
     readonly SEARCH: "search";
+    readonly SEARCH_HISTORY: "search_history";
     readonly PLAYLISTS: "playlists";
     readonly ARTIST: "artist";
     readonly ALBUM: "album";
@@ -13,6 +14,10 @@ export declare const VIEW: {
     readonly SETTINGS: "settings";
     readonly CONFIG: "config";
     readonly PLUGINS: "plugins";
+    readonly LYRICS: "lyrics";
+    readonly KEYBINDINGS: "keybindings";
+    readonly TRENDING: "trending";
+    readonly EXPLORE: "explore";
 };
 export declare const SEARCH_TYPE: {
     readonly ALL: "all";
@@ -33,10 +38,14 @@ export declare const KEYBINDINGS: {
     readonly PREVIOUS: readonly ["b", "left"];
     readonly VOLUME_UP: readonly ["="];
     readonly VOLUME_DOWN: readonly ["-"];
+    readonly VOLUME_FINE_UP: readonly ["shift+="];
+    readonly VOLUME_FINE_DOWN: readonly ["shift+-"];
     readonly SHUFFLE: readonly ["s"];
     readonly REPEAT: readonly ["r"];
     readonly SEEK_FORWARD: readonly ["shift+right"];
     readonly SEEK_BACKWARD: readonly ["shift+left"];
+    readonly SPEED_UP: readonly [">"];
+    readonly SPEED_DOWN: readonly ["<"];
     readonly UP: readonly ["up", "k"];
     readonly DOWN: readonly ["down", "j"];
     readonly SELECT: readonly ["enter", "return"];

package/dist/source/utils/constants.js

@@ -10,6 +10,7 @@ export const CONFIG_FILE = `${CONFIG_DIR}/config.json`;
 export const VIEW = {
     PLAYER: 'player',
     SEARCH: 'search',
+    SEARCH_HISTORY: 'search_history',
     PLAYLISTS: 'playlists',
     ARTIST: 'artist',
     ALBUM: 'album',
@@ -18,6 +19,10 @@ export const VIEW = {
     SETTINGS: 'settings',
     CONFIG: 'config',
     PLUGINS: 'plugins',
+    LYRICS: 'lyrics',
+    KEYBINDINGS: 'keybindings',
+    TRENDING: 'trending',
+    EXPLORE: 'explore',
 };
 // Search types
 export const SEARCH_TYPE = {
@@ -42,10 +47,14 @@ export const KEYBINDINGS = {
     PREVIOUS: ['b', 'left'],
     VOLUME_UP: ['='], // Only '=' without shift, since '+' requires shift and causes issues
     VOLUME_DOWN: ['-'], // Only '-' without shift
+    VOLUME_FINE_UP: ['shift+='], // Fine-grained +1 step
+    VOLUME_FINE_DOWN: ['shift+-'], // Fine-grained -1 step
     SHUFFLE: ['s'],
     REPEAT: ['r'],
     SEEK_FORWARD: ['shift+right'],
     SEEK_BACKWARD: ['shift+left'],
+    SPEED_UP: ['>'],
+    SPEED_DOWN: ['<'],
     // Navigation
     UP: ['up', 'k'],
     DOWN: ['down', 'j'],

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@involvex/youtube-music-cli",
-	"version": "0.0.2",
+	"version": "0.0.3",
 	"description": "- A Commandline music player for youtube-music",
 	"repository": {
 		"type": "git",
@@ -32,7 +32,8 @@
 		"test": "prettier --check . && xo && ava",
 		"typecheck": "tsc --noEmit",
 		"changelog": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
-		"clean": "rimraf dist"
+		"clean": "rimraf dist",
+		"release": "powershell -File scripts/release.ps1"
 	},
 	"xo": {
 		"extends": "xo-react",
@@ -59,6 +60,7 @@
 		"ink-text-input": "^6.0.0",
 		"jiti": "^2.6.1",
 		"meow": "^14.0.0",
+		"node-notifier": "^10.0.1",
 		"node-youtube-music": "^0.10.3",
 		"play-sound": "^1.1.6",
 		"react": "^19.2.4",
@@ -68,6 +70,7 @@
 	"devDependencies": {
 		"@eslint/js": "^10.0.1",
 		"@sindresorhus/tsconfig": "^8.1.0",
+		"@types/node-notifier": "^8.0.5",
 		"@types/react": "^19.2.14",
 		"@vdemedes/prettier-config": "^2.0.1",
 		"ava": "^6.4.1",