@involvex/youtube-music-cli 0.0.0

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

@@ -0,0 +1,206 @@
+import { CONFIG_DIR } from "../../utils/constants.js";
+import { logger } from "../logger/logger.service.js";
+import { join } from 'node:path';
+import { existsSync, mkdirSync, rmSync, cpSync, readdirSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+const PLUGINS_DIR = join(CONFIG_DIR, 'plugins');
+/**
+ * Plugin updater service
+ */
+class PluginUpdaterService {
+    /**
+     * Check if updates are available for a plugin
+     */
+    async checkForUpdates(pluginId) {
+        const pluginDir = join(PLUGINS_DIR, pluginId);
+        if (!existsSync(pluginDir)) {
+            return { hasUpdate: false };
+        }
+        // Check if plugin is a git repository
+        const gitDir = join(pluginDir, '.git');
+        if (!existsSync(gitDir)) {
+            logger.warn('PluginUpdaterService', `Plugin ${pluginId} is not a git repository, cannot check for updates`);
+            return { hasUpdate: false };
+        }
+        try {
+            // Fetch latest from remote
+            execSync('git fetch origin', {
+                cwd: pluginDir,
+                stdio: 'pipe',
+                windowsHide: true,
+            });
+            // Check if local is behind remote
+            const status = execSync('git status -uno', {
+                cwd: pluginDir,
+                stdio: 'pipe',
+                windowsHide: true,
+            }).toString();
+            const hasUpdate = status.includes('Your branch is behind');
+            // Get current version from manifest
+            const manifestPath = join(pluginDir, 'plugin.json');
+            let currentVersion = 'unknown';
+            if (existsSync(manifestPath)) {
+                const { readFileSync: fsReadFileSync } = await import('node:fs');
+                const manifest = fsReadFileSync(manifestPath, 'utf-8');
+                const parsedManifest = typeof manifest === 'string' ? JSON.parse(manifest) : manifest;
+                currentVersion = parsedManifest.version;
+            }
+            return {
+                hasUpdate,
+                currentVersion,
+                latestVersion: hasUpdate ? 'available' : currentVersion,
+            };
+        }
+        catch (error) {
+            logger.error('PluginUpdaterService', `Failed to check updates for ${pluginId}:`, error);
+            return { hasUpdate: false };
+        }
+    }
+    /**
+     * Update a plugin with smart merge (preserve user data)
+     */
+    async updatePlugin(pluginId) {
+        const pluginDir = join(PLUGINS_DIR, pluginId);
+        if (!existsSync(pluginDir)) {
+            return {
+                success: false,
+                error: `Plugin ${pluginId} is not installed`,
+            };
+        }
+        try {
+            // Get current version
+            const manifestPath = join(pluginDir, 'plugin.json');
+            let oldVersion = 'unknown';
+            if (existsSync(manifestPath)) {
+                const { readFileSync: fsReadFileSync } = await import('node:fs');
+                const manifest = fsReadFileSync(manifestPath, 'utf-8');
+                const parsedManifest = typeof manifest === 'string' ? JSON.parse(manifest) : manifest;
+                oldVersion = parsedManifest.version;
+            }
+            // Backup current version
+            const backupDir = join(pluginDir, '.backup');
+            if (existsSync(backupDir)) {
+                rmSync(backupDir, { recursive: true, force: true });
+            }
+            mkdirSync(backupDir, { recursive: true });
+            // Backup everything except data/ and config.json
+            const entries = readdirSync(pluginDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name === 'data' ||
+                    entry.name === 'config.json' ||
+                    entry.name === '.backup') {
+                    continue;
+                }
+                const sourcePath = join(pluginDir, entry.name);
+                const targetPath = join(backupDir, entry.name);
+                if (entry.isDirectory()) {
+                    cpSync(sourcePath, targetPath, { recursive: true });
+                }
+                else {
+                    cpSync(sourcePath, targetPath);
+                }
+            }
+            // Check if it's a git repository
+            const gitDir = join(pluginDir, '.git');
+            if (existsSync(gitDir)) {
+                // Git pull
+                try {
+                    execSync('git pull origin main', {
+                        cwd: pluginDir,
+                        stdio: 'pipe',
+                        windowsHide: true,
+                    });
+                }
+                catch {
+                    // Try master branch
+                    execSync('git pull origin master', {
+                        cwd: pluginDir,
+                        stdio: 'pipe',
+                        windowsHide: true,
+                    });
+                }
+            }
+            else {
+                logger.warn('PluginUpdaterService', `Plugin ${pluginId} is not a git repository, cannot update`);
+                return {
+                    success: false,
+                    error: 'Plugin is not a git repository',
+                };
+            }
+            // Get new version
+            let newVersion = 'unknown';
+            if (existsSync(manifestPath)) {
+                const { readFileSync: fsReadFileSync } = await import('node:fs');
+                const manifest = fsReadFileSync(manifestPath, 'utf-8');
+                const parsedManifest = typeof manifest === 'string' ? JSON.parse(manifest) : manifest;
+                newVersion = parsedManifest.version;
+            }
+            // Install/update dependencies
+            const packageJsonPath = join(pluginDir, 'package.json');
+            if (existsSync(packageJsonPath)) {
+                try {
+                    execSync('bun install', {
+                        cwd: pluginDir,
+                        stdio: 'pipe',
+                        windowsHide: true,
+                    });
+                }
+                catch (error) {
+                    logger.warn('PluginUpdaterService', 'Failed to install dependencies:', error);
+                }
+            }
+            logger.info('PluginUpdaterService', `Successfully updated ${pluginId} from ${oldVersion} to ${newVersion}`);
+            return {
+                success: true,
+                pluginId,
+                oldVersion,
+                newVersion,
+                message: `Updated from ${oldVersion} to ${newVersion}`,
+            };
+        }
+        catch (error) {
+            logger.error('PluginUpdaterService', `Failed to update ${pluginId}:`, error);
+            // Try to restore from backup
+            const backupDir = join(pluginDir, '.backup');
+            if (existsSync(backupDir)) {
+                logger.info('PluginUpdaterService', 'Restoring from backup...');
+                try {
+                    const entries = readdirSync(backupDir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        const sourcePath = join(backupDir, entry.name);
+                        const targetPath = join(pluginDir, entry.name);
+                        // Remove target first
+                        if (existsSync(targetPath)) {
+                            rmSync(targetPath, { recursive: true, force: true });
+                        }
+                        if (entry.isDirectory()) {
+                            cpSync(sourcePath, targetPath, { recursive: true });
+                        }
+                        else {
+                            cpSync(sourcePath, targetPath);
+                        }
+                    }
+                    logger.info('PluginUpdaterService', 'Restored from backup');
+                }
+                catch (restoreError) {
+                    logger.error('PluginUpdaterService', 'Failed to restore from backup:', restoreError);
+                }
+            }
+            return {
+                success: false,
+                error: `Update failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+}
+// Singleton instance
+let instance = null;
+/**
+ * Get the plugin updater service singleton
+ */
+export function getPluginUpdaterService() {
+    if (!instance) {
+        instance = new PluginUpdaterService();
+    }
+    return instance;
+}

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

@@ -0,0 +1,13 @@
+import type { Track, Album, Artist, Playlist, SearchOptions, SearchResponse } from '../../types/youtube-music.types.ts';
+declare class MusicService {
+    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>;
+    getSuggestions(trackId: string): Promise<Track[]>;
+    getStreamUrl(videoId: string): Promise<string>;
+    private getInvidiousStreamUrl;
+}
+export declare function getMusicService(): MusicService;
+export {};

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

@@ -0,0 +1,371 @@
+import { Innertube } from 'youtubei.js';
+import { logger } from "../logger/logger.service.js";
+// Initialize YouTube client
+let ytClient = null;
+async function getClient() {
+    if (!ytClient) {
+        ytClient = await Innertube.create();
+    }
+    return ytClient;
+}
+class MusicService {
+    async search(query, options = {}) {
+        const results = [];
+        const searchType = options.type || 'all';
+        try {
+            const yt = await getClient();
+            const search = (await yt.search(query));
+            // Process search results based on type
+            if (searchType === 'all' || searchType === 'songs') {
+                const videos = search.videos;
+                if (videos) {
+                    for (const video of videos) {
+                        if (video.type === 'Video' || video.id) {
+                            results.push({
+                                type: 'song',
+                                data: {
+                                    videoId: video.id || video.video_id || '',
+                                    title: (typeof video.title === 'string'
+                                        ? video.title
+                                        : video.title?.text) || 'Unknown',
+                                    artists: [
+                                        {
+                                            artistId: video.channel_id || video.channel?.id || '',
+                                            name: (typeof video.author === 'string'
+                                                ? video.author
+                                                : video.author?.name) || 'Unknown',
+                                        },
+                                    ],
+                                    duration: (typeof video.duration === 'number'
+                                        ? video.duration
+                                        : video.duration?.seconds) || 0,
+                                },
+                            });
+                        }
+                    }
+                }
+            }
+            if (searchType === 'all' || searchType === 'playlists') {
+                const playlists = search.playlists;
+                if (playlists) {
+                    for (const playlist of playlists) {
+                        results.push({
+                            type: 'playlist',
+                            data: {
+                                playlistId: playlist.id || '',
+                                name: (typeof playlist.title === 'string'
+                                    ? playlist.title
+                                    : playlist.title?.text) || 'Unknown Playlist',
+                                tracks: [],
+                            },
+                        });
+                    }
+                }
+            }
+            if (searchType === 'all' || searchType === 'artists') {
+                const channels = search.channels;
+                if (channels) {
+                    for (const channel of channels) {
+                        results.push({
+                            type: 'artist',
+                            data: {
+                                artistId: channel.id || channel.channelId || '',
+                                name: (typeof channel.author === 'string'
+                                    ? channel.author
+                                    : channel.author?.name) || 'Unknown Artist',
+                            },
+                        });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Search failed:', error);
+        }
+        return {
+            results,
+            hasMore: false,
+        };
+    }
+    async getTrack(videoId) {
+        return {
+            videoId,
+            title: 'Unknown Track',
+            artists: [],
+        };
+    }
+    async getAlbum(albumId) {
+        return {
+            albumId,
+            name: 'Unknown Album',
+            artists: [],
+            tracks: [],
+        };
+    }
+    async getArtist(artistId) {
+        return {
+            artistId,
+            name: 'Unknown Artist',
+        };
+    }
+    async getPlaylist(playlistId) {
+        return {
+            playlistId,
+            name: 'Unknown Playlist',
+            tracks: [],
+        };
+    }
+    async getSuggestions(trackId) {
+        try {
+            const yt = await getClient();
+            const video = (await yt.getInfo(trackId));
+            const suggestions = video.related?.contents || [];
+            return suggestions.slice(0, 10).map((item) => ({
+                videoId: item.id || '',
+                title: typeof item.title === 'string'
+                    ? item.title
+                    : item.title?.text || 'Unknown',
+                artists: [],
+            }));
+        }
+        catch (error) {
+            console.error('Failed to get suggestions:', error);
+            return [];
+        }
+    }
+    async getStreamUrl(videoId) {
+        logger.info('MusicService', 'Starting stream extraction', { videoId });
+        // Try Method 1: @distube/ytdl-core (most reliable, actively maintained)
+        try {
+            logger.debug('MusicService', 'Attempting ytdl-core extraction', {
+                videoId,
+            });
+            const ytdl = await import('@distube/ytdl-core');
+            const videoUrl = `https://www.youtube.com/watch?v=${videoId}`;
+            const info = await ytdl.default.getInfo(videoUrl);
+            logger.debug('MusicService', 'ytdl-core getInfo succeeded', {
+                formatCount: info.formats.length,
+            });
+            const audioFormats = ytdl.default.filterFormats(info.formats, 'audioonly');
+            logger.debug('MusicService', 'ytdl-core audio formats filtered', {
+                audioFormatCount: audioFormats.length,
+            });
+            if (audioFormats.length > 0) {
+                // Get highest quality audio
+                const bestAudio = audioFormats.sort((a, b) => {
+                    const aBitrate = Number.parseInt(String(a.audioBitrate || 0));
+                    const bBitrate = Number.parseInt(String(b.audioBitrate || 0));
+                    return bBitrate - aBitrate;
+                })[0];
+                if (bestAudio?.url) {
+                    logger.info('MusicService', 'Using ytdl-core stream', {
+                        bitrate: bestAudio.audioBitrate,
+                        urlLength: bestAudio.url.length,
+                        mimeType: bestAudio.mimeType,
+                    });
+                    return bestAudio.url;
+                }
+            }
+            logger.warn('MusicService', 'ytdl-core: No audio formats with URL found');
+        }
+        catch (error) {
+            logger.error('MusicService', 'ytdl-core extraction failed', {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+        // Try Method 2: youtubei.js (may fail with ParsingError)
+        try {
+            logger.debug('MusicService', 'Attempting youtubei.js extraction', {
+                videoId,
+            });
+            const yt = await getClient();
+            const video = (await yt.getInfo(videoId));
+            logger.debug('MusicService', 'youtubei.js getInfo succeeded');
+            // Get the download URL for the video
+            const streamData = video.chooseFormat?.({
+                type: 'audio',
+                quality: 'best',
+            });
+            if (streamData?.url) {
+                logger.info('MusicService', 'Using youtubei.js stream (chooseFormat)', {
+                    urlLength: streamData.url.length,
+                });
+                return streamData.url;
+            }
+            // Fallback: Manually select from streaming_data.adaptive_formats
+            logger.debug('MusicService', 'chooseFormat returned nothing, trying manual selection');
+            const streamingData = video.streaming_data;
+            if (streamingData?.adaptive_formats) {
+                logger.debug('MusicService', 'Found adaptive_formats', {
+                    count: streamingData.adaptive_formats.length,
+                });
+                // Filter for audio-only formats
+                const audioFormats = streamingData.adaptive_formats.filter((f) => f.mime_type?.includes('audio') || f.type?.includes('audio'));
+                logger.debug('MusicService', 'Audio formats found', {
+                    count: audioFormats.length,
+                });
+                if (audioFormats.length > 0) {
+                    // Sort by bitrate (higher is better)
+                    const sorted = audioFormats.sort((a, b) => {
+                        const aBitrate = Number.parseInt(String(a.bitrate || 0));
+                        const bBitrate = Number.parseInt(String(b.bitrate || 0));
+                        return bBitrate - aBitrate;
+                    });
+                    const bestAudio = sorted[0];
+                    if (bestAudio) {
+                        // Check for direct URL
+                        if (bestAudio.url) {
+                            logger.info('MusicService', 'Using youtubei.js stream (manual)', {
+                                bitrate: bestAudio.bitrate,
+                                mimeType: bestAudio.mime_type || bestAudio.type,
+                                urlLength: bestAudio.url.length,
+                            });
+                            return bestAudio.url;
+                        }
+                        // Check for signatureCipher (needs decoding)
+                        if (bestAudio.signature_cipher || bestAudio.signatureCipher) {
+                            logger.warn('MusicService', 'Format has signature cipher (not supported)', {
+                                hasCipher: true,
+                            });
+                        }
+                    }
+                }
+            }
+            logger.warn('MusicService', 'youtubei.js: No usable stream URL found');
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('ParsingError')) {
+                logger.warn('MusicService', 'youtubei.js parsing error (expected)', {
+                    error: error.message,
+                });
+            }
+            else {
+                logger.error('MusicService', 'youtubei.js extraction failed', {
+                    error: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined,
+                });
+            }
+        }
+        // Try Method 3: youtube-ext (lightweight, no parsing needed)
+        try {
+            logger.debug('MusicService', 'Attempting youtube-ext extraction', {
+                videoId,
+            });
+            const { videoInfo, getFormats } = await import('youtube-ext');
+            const videoUrl = `https://www.youtube.com/watch?v=${videoId}`;
+            const info = await videoInfo(videoUrl);
+            logger.debug('MusicService', 'youtube-ext videoInfo succeeded');
+            // Decode stream URLs first
+            const decodedFormats = await getFormats(info.stream);
+            logger.debug('MusicService', 'youtube-ext formats decoded', {
+                formatCount: decodedFormats.length,
+            });
+            // Get best audio format from decoded adaptive formats
+            const audioFormats = decodedFormats.filter(f => f.mimeType?.includes('audio') && f.url);
+            logger.debug('MusicService', 'youtube-ext audio formats filtered', {
+                audioFormatCount: audioFormats.length,
+            });
+            if (audioFormats.length > 0) {
+                // Sort by bitrate descending and get best quality
+                const bestAudio = audioFormats.sort((a, b) => (b.bitrate || 0) - (a.bitrate || 0))[0];
+                if (bestAudio?.url) {
+                    logger.info('MusicService', 'Using youtube-ext stream', {
+                        bitrate: bestAudio.bitrate,
+                        urlLength: bestAudio.url.length,
+                    });
+                    return bestAudio.url;
+                }
+            }
+            logger.warn('MusicService', 'youtube-ext: No audio formats with URL found');
+        }
+        catch (error) {
+            logger.error('MusicService', 'youtube-ext extraction failed', {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+        // Try Method 4: Invidious API (last resort)
+        try {
+            logger.debug('MusicService', 'Attempting Invidious extraction', {
+                videoId,
+            });
+            const url = await this.getInvidiousStreamUrl(videoId);
+            logger.info('MusicService', 'Using Invidious stream', {
+                urlLength: url.length,
+            });
+            return url;
+        }
+        catch (error) {
+            logger.error('MusicService', 'Invidious extraction failed', {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+        // All methods failed
+        logger.error('MusicService', 'All stream extraction methods failed', {
+            videoId,
+        });
+        throw new Error('All stream extraction methods failed');
+    }
+    async getInvidiousStreamUrl(videoId) {
+        // Try multiple Invidious instances as fallback
+        const instances = [
+            'https://vid.puffyan.us',
+            'https://invidious.perennialte.ch',
+            'https://yewtu.be',
+        ];
+        for (const instance of instances) {
+            try {
+                logger.debug('MusicService', 'Trying Invidious instance', { instance });
+                const response = await fetch(`${instance}/api/v1/videos/${videoId}`);
+                if (!response.ok) {
+                    logger.debug('MusicService', 'Invidious instance returned non-OK', {
+                        instance,
+                        status: response.status,
+                    });
+                    continue;
+                }
+                const videoData = (await response.json());
+                // Look for audio-only streams
+                const audioFormats = [
+                    ...(videoData.adaptiveFormats || []),
+                    ...(videoData.formatStreams || []),
+                ].filter(f => f.type?.toLowerCase().includes('audio'));
+                logger.debug('MusicService', 'Invidious audio formats found', {
+                    instance,
+                    count: audioFormats.length,
+                });
+                if (audioFormats.length > 0) {
+                    const firstAudio = audioFormats[0];
+                    if (firstAudio?.url) {
+                        logger.debug('MusicService', 'Invidious stream URL obtained', {
+                            instance,
+                            urlLength: firstAudio.url.length,
+                            type: firstAudio.type,
+                        });
+                        return firstAudio.url;
+                    }
+                }
+            }
+            catch (error) {
+                logger.debug('MusicService', 'Invidious instance error', {
+                    instance,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                // Try next instance
+                continue;
+            }
+        }
+        // If all Invidious instances fail, throw error instead of returning watch URL
+        throw new Error('No Invidious instance returned a valid stream URL');
+    }
+}
+// Singleton instance
+let musicServiceInstance = null;
+export function getMusicService() {
+    if (!musicServiceInstance) {
+        musicServiceInstance = new MusicService();
+    }
+    return musicServiceInstance;
+}

package/dist/source/services/youtube-music/search.service.d.ts

@@ -0,0 +1,11 @@
+import type { SearchOptions, Track, Album, Artist, Playlist } from '../../types/youtube-music.types.ts';
+declare class SearchService {
+    private musicService;
+    search(query: string, options?: SearchOptions): Promise<import('../../types/youtube-music.types.ts').SearchResponse>;
+    searchSongs(query: string, limit?: number): Promise<Track[]>;
+    searchAlbums(query: string, limit?: number): Promise<Album[]>;
+    searchArtists(query: string, limit?: number): Promise<Artist[]>;
+    searchPlaylists(query: string, limit?: number): Promise<Playlist[]>;
+}
+export declare function getSearchService(): SearchService;
+export {};

package/dist/source/services/youtube-music/search.service.js

@@ -0,0 +1,38 @@
+import { getMusicService } from "./api.js";
+class SearchService {
+    musicService = getMusicService();
+    async search(query, options = {}) {
+        return this.musicService.search(query, options);
+    }
+    async searchSongs(query, limit = 20) {
+        const response = await this.search(query, { type: 'songs', limit });
+        return response.results
+            .filter(r => r.type === 'song')
+            .map(r => r.data);
+    }
+    async searchAlbums(query, limit = 10) {
+        const response = await this.search(query, { type: 'albums', limit });
+        return response.results
+            .filter(r => r.type === 'album')
+            .map(r => r.data);
+    }
+    async searchArtists(query, limit = 10) {
+        const response = await this.search(query, { type: 'artists', limit });
+        return response.results
+            .filter(r => r.type === 'artist')
+            .map(r => r.data);
+    }
+    async searchPlaylists(query, limit = 10) {
+        const response = await this.search(query, { type: 'playlists', limit });
+        return response.results
+            .filter(r => r.type === 'playlist')
+            .map(r => r.data);
+    }
+}
+let searchServiceInstance = null;
+export function getSearchService() {
+    if (!searchServiceInstance) {
+        searchServiceInstance = new SearchService();
+    }
+    return searchServiceInstance;
+}

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

@@ -0,0 +1,10 @@
+import type { NavigationState, NavigationAction } from '../types/navigation.types.ts';
+import { type ReactNode } from 'react';
+export type NavigationContextValue = {
+    state: NavigationState;
+    dispatch: (action: NavigationAction) => void;
+};
+export declare function NavigationProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useNavigation(): NavigationContextValue;