@involvex/youtube-music-cli 0.0.47 → 0.0.48

package/dist/source/main.js

@@ -1,127 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-// Main application orchestrator
-import { NavigationProvider } from "./stores/navigation.store.js";
-import { PluginsProvider } from "./stores/plugins.store.js";
-import MainLayout from "./components/layouts/MainLayout.js";
-import { ThemeProvider } from "./contexts/theme.context.js";
-import { PlayerProvider } from "./stores/player.store.js";
-import { HistoryProvider } from "./stores/history.store.js";
-import { ErrorBoundary } from "./components/common/ErrorBoundary.js";
-import { KeyboardManager } from "./hooks/useKeyboard.js";
-import { KeyboardBlockProvider } from "./hooks/useKeyboardBlocker.js";
-import { Box, Text } from 'ink';
-import { useEffect } from 'react';
-import { useNavigation } from "./hooks/useNavigation.js";
-import { usePlayer } from "./hooks/usePlayer.js";
-import { useYouTubeMusic } from "./hooks/useYouTubeMusic.js";
-import { VIEW } from "./utils/constants.js";
-import { getConfigService } from "./services/config/config.service.js";
-import { getNotificationService } from "./services/notification/notification.service.js";
-function Initializer({ flags }) {
-    const { dispatch } = useNavigation();
-    const { play } = usePlayer();
-    const { getTrack, getPlaylist } = useYouTubeMusic();
-    useEffect(() => {
-        // Check for background playback state on startup
-        const config = getConfigService();
-        const backgroundState = config.getBackgroundPlaybackState();
-        if (backgroundState.enabled) {
-            // Show notification about background playback
-            const notification = getNotificationService();
-            notification.setEnabled(true);
-            void notification.notify('Background Playback Active', 'Press Shift+R to resume control');
-        }
-        if (flags?.showSuggestions) {
-            dispatch({ category: 'NAVIGATE', view: VIEW.SUGGESTIONS });
-        }
-        else if (flags?.searchQuery) {
-            dispatch({ category: 'NAVIGATE', view: VIEW.SEARCH });
-            dispatch({ category: 'SET_SEARCH_QUERY', query: flags.searchQuery });
-        }
-        else if (flags?.playTrack) {
-            void getTrack(flags.playTrack).then(track => {
-                if (track)
-                    play(track);
-            });
-        }
-        else if (flags?.playPlaylist) {
-            dispatch({ category: 'NAVIGATE', view: VIEW.PLAYLISTS });
-            void getPlaylist(flags.playPlaylist).then(playlist => {
-                // For now just navigate, but we could auto-play
-                if (playlist) {
-                    dispatch({ category: 'SET_SELECTED_PLAYLIST', index: 0 });
-                }
-            });
-        }
-    }, [flags, dispatch, play, getTrack, getPlaylist]);
-    return null;
-}
-function HeadlessLayout({ flags }) {
-    const { play, pause, resume, next, previous } = usePlayer();
-    const { getTrack, getPlaylist, search } = useYouTubeMusic();
-    useEffect(() => {
-        void (async () => {
-            if (flags?.playTrack) {
-                const track = await getTrack(flags.playTrack);
-                if (!track) {
-                    console.error(`Track not found: ${flags.playTrack}`);
-                    process.exitCode = 1;
-                    return;
-                }
-                play(track);
-                console.log(`Playing: ${track.title}`);
-                return;
-            }
-            if (flags?.searchQuery) {
-                const response = await search(flags.searchQuery, {
-                    type: 'songs',
-                    limit: 1,
-                });
-                const songResult = response?.results.find(result => result.type === 'song');
-                if (!songResult) {
-                    console.error(`No playable tracks found for: "${flags.searchQuery}"`);
-                    process.exitCode = 1;
-                    return;
-                }
-                const track = songResult.data;
-                play(track, { clearQueue: true });
-                console.log(`Playing: ${track.title}`);
-                return;
-            }
-            if (flags?.playPlaylist) {
-                const playlist = await getPlaylist(flags.playPlaylist);
-                const firstTrack = playlist?.tracks[0];
-                if (!firstTrack) {
-                    console.error(`No playable tracks found in playlist: ${flags.playPlaylist}`);
-                    process.exitCode = 1;
-                    return;
-                }
-                play(firstTrack, { clearQueue: true });
-                console.log(`Playing playlist "${playlist.name}": ${firstTrack.title}`);
-                return;
-            }
-            if (flags?.action === 'pause')
-                pause();
-            if (flags?.action === 'resume')
-                resume();
-            if (flags?.action === 'next')
-                next();
-            if (flags?.action === 'previous')
-                previous();
-        })();
-    }, [
-        flags,
-        play,
-        pause,
-        resume,
-        next,
-        previous,
-        getTrack,
-        getPlaylist,
-        search,
-    ]);
-    return (_jsx(Box, { padding: 1, children: _jsx(Text, { color: "green", children: "Headless mode active." }) }));
-}
-export default function Main({ flags }) {
-    return (_jsx(ErrorBoundary, { children: _jsx(ThemeProvider, { children: _jsx(PlayerProvider, { children: _jsx(HistoryProvider, { children: _jsx(NavigationProvider, { children: _jsx(PluginsProvider, { children: _jsx(KeyboardBlockProvider, { children: _jsxs(Box, { flexDirection: "column", children: [_jsx(KeyboardManager, {}), flags?.headless ? (_jsx(HeadlessLayout, { flags: flags })) : (_jsxs(_Fragment, { children: [_jsx(Initializer, { flags: flags }), _jsx(MainLayout, {})] }))] }) }) }) }) }) }) }) }));
-}

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

@@ -1,67 +0,0 @@
-// In-memory LRU cache with optional TTL for API responses
-import { logger } from "../logger/logger.service.js";
-export class CacheService {
-    cache = new Map();
-    maxSize;
-    defaultTtlMs;
-    constructor(maxSize = 100, defaultTtlMs = 5 * 60 * 1000) {
-        this.maxSize = maxSize;
-        this.defaultTtlMs = defaultTtlMs;
-    }
-    get(key) {
-        const entry = this.cache.get(key);
-        if (!entry)
-            return null;
-        if (Date.now() > entry.expiresAt) {
-            this.cache.delete(key);
-            return null;
-        }
-        entry.lastAccessed = Date.now();
-        return entry.value;
-    }
-    set(key, value, ttlMs) {
-        // Evict LRU entry if at capacity
-        if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
-            this.evictLru();
-        }
-        this.cache.set(key, {
-            value,
-            expiresAt: Date.now() + (ttlMs ?? this.defaultTtlMs),
-            lastAccessed: Date.now(),
-        });
-    }
-    has(key) {
-        return this.get(key) !== null;
-    }
-    delete(key) {
-        this.cache.delete(key);
-    }
-    clear() {
-        this.cache.clear();
-    }
-    get size() {
-        return this.cache.size;
-    }
-    evictLru() {
-        let lruKey = null;
-        let lruTime = Infinity;
-        for (const [key, entry] of this.cache) {
-            if (entry.lastAccessed < lruTime) {
-                lruTime = entry.lastAccessed;
-                lruKey = key;
-            }
-        }
-        if (lruKey) {
-            logger.debug('CacheService', 'Evicting LRU entry', { key: lruKey });
-            this.cache.delete(lruKey);
-        }
-    }
-}
-// Shared search result cache (100 entries, 5min TTL)
-let searchCacheInstance = null;
-export const getSearchCache = () => {
-    if (!searchCacheInstance) {
-        searchCacheInstance = new CacheService(100, 5 * 60 * 1000);
-    }
-    return searchCacheInstance;
-};

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

@@ -1,313 +0,0 @@
-const COMMANDS = [
-    'play',
-    'search',
-    'playlist',
-    'suggestions',
-    'pause',
-    'resume',
-    'skip',
-    'back',
-    'plugins',
-    'import',
-    'completions',
-];
-const PLUGINS_SUBCOMMANDS = [
-    'list',
-    'install',
-    'remove',
-    'uninstall',
-    'update',
-    'enable',
-    'disable',
-];
-const IMPORT_SUBCOMMANDS = ['spotify', 'youtube'];
-const COMPLETIONS_SUBCOMMANDS = [
-    'bash',
-    'zsh',
-    'powershell',
-    'fish',
-];
-const FLAGS = [
-    '--theme',
-    '--volume',
-    '--shuffle',
-    '--repeat',
-    '--headless',
-    '--web',
-    '--web-host',
-    '--web-port',
-    '--web-only',
-    '--web-auth',
-    '--name',
-    '--help',
-    '--version',
-];
-export function generateCompletion(shell) {
-    switch (shell) {
-        case 'bash':
-            return generateBashCompletion();
-        case 'zsh':
-            return generateZshCompletion();
-        case 'powershell':
-            return generatePowerShellCompletion();
-        case 'fish':
-            return generateFishCompletion();
-    }
-}
-function generateBashCompletion() {
-    const cmds = COMMANDS.join(' ');
-    const pluginsSubs = PLUGINS_SUBCOMMANDS.join(' ');
-    const importSubs = IMPORT_SUBCOMMANDS.join(' ');
-    const completionsSubs = COMPLETIONS_SUBCOMMANDS.join(' ');
-    const flags = FLAGS.join(' ');
-    return `# youtube-music-cli bash completion
-# Add to ~/.bashrc or ~/.bash_profile:
-#   source <(ymc completions bash)
-#   # or:
-#   ymc completions bash >> ~/.bash_completion
-
-_ymc_completions() {
-    local cur prev words cword
-    _init_completion || return
-
-    local commands="${cmds}"
-    local flags="${flags}"
-
-    case "$prev" in
-        plugins)
-            COMPREPLY=($(compgen -W "${pluginsSubs}" -- "$cur"))
-            return ;;
-        import)
-            COMPREPLY=($(compgen -W "${importSubs}" -- "$cur"))
-            return ;;
-        completions)
-            COMPREPLY=($(compgen -W "${completionsSubs}" -- "$cur"))
-            return ;;
-        --theme|-t)
-            COMPREPLY=($(compgen -W "dark light midnight matrix" -- "$cur"))
-            return ;;
-        --repeat|-r)
-            COMPREPLY=($(compgen -W "off all one" -- "$cur"))
-            return ;;
-    esac
-
-    if [[ "$cur" == -* ]]; then
-        COMPREPLY=($(compgen -W "$flags" -- "$cur"))
-    else
-        COMPREPLY=($(compgen -W "$commands" -- "$cur"))
-    fi
-}
-
-complete -F _ymc_completions ymc youtube-music-cli
-`;
-}
-function generateZshCompletion() {
-    return `#compdef ymc youtube-music-cli
-# youtube-music-cli zsh completion
-# Add to your zsh config:
-#   source <(ymc completions zsh)
-#   # or copy to a directory in $fpath:
-#   ymc completions zsh > ~/.zsh/completions/_ymc
-
-_ymc() {
-    local -a commands subcommands flags
-
-    commands=(
-        'play:Play a track by ID or YouTube URL'
-        'search:Search for tracks'
-        'playlist:Play a playlist by ID'
-        'suggestions:Show music suggestions'
-        'pause:Pause playback'
-        'resume:Resume playback'
-        'skip:Skip to next track'
-        'back:Go to previous track'
-        'plugins:Manage plugins'
-        'import:Import playlists from Spotify or YouTube'
-        'completions:Generate shell completion scripts'
-    )
-
-    flags=(
-        '--theme[Theme to use]:theme:(dark light midnight matrix)'
-        '--volume[Initial volume (0-100)]:volume:'
-        '--shuffle[Enable shuffle mode]'
-        '--repeat[Repeat mode]:mode:(off all one)'
-        '--headless[Run without TUI]'
-        '--web[Enable web UI server]'
-        '--web-host[Web server host]:host:'
-        '--web-port[Web server port]:port:'
-        '--web-only[Run web server without CLI UI]'
-        '--web-auth[Authentication token for web server]:token:'
-        '--name[Custom name for imported playlist]:name:'
-        '--help[Show help]'
-        '--version[Show version]'
-    )
-
-    case $words[2] in
-        plugins)
-            local -a plugin_cmds
-            plugin_cmds=(
-                'list:List installed plugins'
-                'install:Install a plugin'
-                'remove:Remove a plugin'
-                'uninstall:Alias for remove'
-                'update:Update a plugin'
-                'enable:Enable a plugin'
-                'disable:Disable a plugin'
-            )
-            _describe 'plugin commands' plugin_cmds
-            return ;;
-        import)
-            local -a import_sources
-            import_sources=('spotify:Import from Spotify' 'youtube:Import from YouTube')
-            _describe 'import sources' import_sources
-            return ;;
-        completions)
-            local -a shells
-            shells=('bash:Bash completion' 'zsh:Zsh completion' 'powershell:PowerShell completion' 'fish:Fish completion')
-            _describe 'shells' shells
-            return ;;
-    esac
-
-    _arguments -s \\
-        $flags \\
-        '1:command:->cmd' \\
-        '*::args:->args'
-
-    case $state in
-        cmd)
-            _describe 'commands' commands ;;
-        args)
-            _message 'arguments' ;;
-    esac
-}
-
-_ymc
-`;
-}
-function generatePowerShellCompletion() {
-    const cmds = COMMANDS.map(c => `'${c}'`).join(', ');
-    const pluginsSubs = PLUGINS_SUBCOMMANDS.map(c => `'${c}'`).join(', ');
-    const importSubs = IMPORT_SUBCOMMANDS.map(c => `'${c}'`).join(', ');
-    const completionsSubs = COMPLETIONS_SUBCOMMANDS.map(c => `'${c}'`).join(', ');
-    const flags = FLAGS.map(f => `'${f}'`).join(', ');
-    return `# youtube-music-cli PowerShell completion
-# Add to your PowerShell profile ($PROFILE):
-#   ymc completions powershell | Out-File -Append $PROFILE
-#   # or:
-#   Invoke-Expression (ymc completions powershell | Out-String)
-
-$ymcCompleterBlock = {
-    param($wordToComplete, $commandAst, $cursorPosition)
-
-    $commands = @(${cmds})
-    $pluginsSubCommands = @(${pluginsSubs})
-    $importSubCommands = @(${importSubs})
-    $completionsSubCommands = @(${completionsSubs})
-    $flags = @(${flags})
-    $themes = @('dark', 'light', 'midnight', 'matrix')
-    $repeatModes = @('off', 'all', 'one')
-
-    $tokens = $commandAst.CommandElements
-    $prevToken = if ($tokens.Count -ge 2) { $tokens[$tokens.Count - 2].ToString() } else { '' }
-    $firstArg = if ($tokens.Count -ge 2) { $tokens[1].ToString() } else { '' }
-
-    # Context-aware completions
-    switch ($prevToken) {
-        'plugins' {
-            $pluginsSubCommands | Where-Object { $_ -like "$wordToComplete*" } |
-                ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }
-            return
-        }
-        'import' {
-            $importSubCommands | Where-Object { $_ -like "$wordToComplete*" } |
-                ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }
-            return
-        }
-        'completions' {
-            $completionsSubCommands | Where-Object { $_ -like "$wordToComplete*" } |
-                ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }
-            return
-        }
-        { $_ -in '--theme', '-t' } {
-            $themes | Where-Object { $_ -like "$wordToComplete*" } |
-                ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }
-            return
-        }
-        { $_ -in '--repeat', '-r' } {
-            $repeatModes | Where-Object { $_ -like "$wordToComplete*" } |
-                ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }
-            return
-        }
-    }
-
-    if ($wordToComplete.StartsWith('-')) {
-        $flags | Where-Object { $_ -like "$wordToComplete*" } |
-            ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }
-    } elseif ($firstArg -eq $wordToComplete -or $tokens.Count -le 1) {
-        $commands | Where-Object { $_ -like "$wordToComplete*" } |
-            ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }
-    }
-}
-
-Register-ArgumentCompleter -Native -CommandName @('ymc', 'youtube-music-cli') -ScriptBlock $ymcCompleterBlock
-`;
-}
-function generateFishCompletion() {
-    const commandCompletions = COMMANDS.map(cmd => `complete -c ymc -n '__fish_use_subcommand' -f -a '${cmd}' -d '${getFishDescription(cmd)}'`).join('\n');
-    const pluginsCompletions = PLUGINS_SUBCOMMANDS.map(sub => `complete -c ymc -n '__fish_seen_subcommand_from plugins' -f -a '${sub}'`).join('\n');
-    const importCompletions = IMPORT_SUBCOMMANDS.map(sub => `complete -c ymc -n '__fish_seen_subcommand_from import' -f -a '${sub}'`).join('\n');
-    const completionsCompletions = COMPLETIONS_SUBCOMMANDS.map(sub => `complete -c ymc -n '__fish_seen_subcommand_from completions' -f -a '${sub}'`).join('\n');
-    return `# youtube-music-cli fish completion
-# Save to: ~/.config/fish/completions/ymc.fish
-#   ymc completions fish > ~/.config/fish/completions/ymc.fish
-
-# Disable file completions by default
-complete -c ymc -f
-
-# Main commands
-${commandCompletions}
-
-# Plugins subcommands
-${pluginsCompletions}
-
-# Import subcommands
-${importCompletions}
-
-# Completions subcommands
-${completionsCompletions}
-
-# Flags
-complete -c ymc -l theme -s t -d 'Theme to use' -r -a 'dark light midnight matrix'
-complete -c ymc -l volume -s v -d 'Initial volume (0-100)' -r
-complete -c ymc -l shuffle -s s -d 'Enable shuffle mode'
-complete -c ymc -l repeat -s r -d 'Repeat mode' -r -a 'off all one'
-complete -c ymc -l headless -d 'Run without TUI'
-complete -c ymc -l web -d 'Enable web UI server'
-complete -c ymc -l web-host -d 'Web server host' -r
-complete -c ymc -l web-port -d 'Web server port' -r
-complete -c ymc -l web-only -d 'Run web server without CLI UI'
-complete -c ymc -l web-auth -d 'Authentication token for web server' -r
-complete -c ymc -l name -d 'Custom name for imported playlist' -r
-complete -c ymc -l help -s h -d 'Show help'
-complete -c ymc -l version -d 'Show version'
-
-# Also register for youtube-music-cli
-complete -c youtube-music-cli -w ymc
-`;
-}
-function getFishDescription(cmd) {
-    const descriptions = {
-        play: 'Play a track by ID or YouTube URL',
-        search: 'Search for tracks',
-        playlist: 'Play a playlist by ID',
-        suggestions: 'Show music suggestions',
-        pause: 'Pause playback',
-        resume: 'Resume playback',
-        skip: 'Skip to next track',
-        back: 'Go to previous track',
-        plugins: 'Manage plugins',
-        import: 'Import playlists from Spotify or YouTube',
-        completions: 'Generate shell completion scripts',
-    };
-    return descriptions[cmd] ?? cmd;
-}

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

@@ -1,191 +0,0 @@
-// Configuration management service
-import { CONFIG_DIR, CONFIG_FILE } from "../../utils/constants.js";
-import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
-import { BUILTIN_THEMES, DEFAULT_THEME } from "../../config/themes.config.js";
-import path from 'node:path';
-class ConfigService {
-    configPath;
-    configDir;
-    config;
-    constructor() {
-        this.configDir = CONFIG_DIR;
-        this.configPath = CONFIG_FILE;
-        this.config = this.load() || this.getDefaultConfig();
-    }
-    getDefaultConfig() {
-        return {
-            theme: 'dark',
-            volume: 70,
-            keybindings: {},
-            playlists: [],
-            history: [],
-            searchHistory: [],
-            favorites: [],
-            repeat: 'off',
-            shuffle: false,
-            customTheme: undefined,
-            streamQuality: 'high',
-            audioNormalization: false,
-            notifications: false,
-            discordRichPresence: false,
-            downloadsEnabled: false,
-            downloadDirectory: path.join(CONFIG_DIR, 'downloads'),
-            downloadFormat: 'mp3',
-            webServer: {
-                enabled: false,
-                host: 'localhost',
-                port: 8080,
-                enableCors: true,
-                allowedOrigins: ['*'],
-                auth: {
-                    enabled: false,
-                },
-            },
-            gaplessPlayback: true,
-            crossfadeDuration: 0,
-            volumeFadeDuration: 0,
-            equalizerPreset: 'flat',
-        };
-    }
-    load() {
-        try {
-            if (!existsSync(this.configPath)) {
-                return null;
-            }
-            const data = readFileSync(this.configPath, 'utf-8');
-            const config = JSON.parse(data);
-            // Merge with defaults to handle new fields
-            return { ...this.getDefaultConfig(), ...config };
-        }
-        catch {
-            return null;
-        }
-    }
-    save() {
-        try {
-            // Ensure config directory exists
-            if (!existsSync(this.configDir)) {
-                mkdirSync(this.configDir, { recursive: true });
-            }
-            writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
-        }
-        catch (error) {
-            console.error('Failed to save config:', error);
-        }
-    }
-    get(key) {
-        return this.config[key];
-    }
-    set(key, value) {
-        this.config[key] = value;
-        this.save();
-    }
-    updateTheme(themeName) {
-        this.config.theme = themeName;
-        this.save();
-    }
-    getTheme() {
-        if (this.config.theme === 'custom' && this.config.customTheme) {
-            return this.config.customTheme;
-        }
-        const builtinTheme = BUILTIN_THEMES[this.config.theme];
-        if (builtinTheme) {
-            return builtinTheme;
-        }
-        return DEFAULT_THEME;
-    }
-    setCustomTheme(theme) {
-        this.config.customTheme = theme;
-        this.config.theme = 'custom';
-        this.save();
-    }
-    getKeybinding(action) {
-        return this.config.keybindings[action]?.keys;
-    }
-    setKeybinding(action, keys) {
-        this.config.keybindings[action] = {
-            keys,
-            description: `Custom binding for ${action}`,
-        };
-        this.save();
-    }
-    addToHistory(trackId) {
-        // Add to front of history, limit to 1000
-        this.config.history = [
-            trackId,
-            ...this.config.history.filter(id => id !== trackId),
-        ].slice(0, 1000);
-        this.save();
-    }
-    getHistory() {
-        return this.config.history;
-    }
-    addToSearchHistory(query) {
-        const trimmed = query.trim();
-        if (!trimmed)
-            return;
-        this.config.searchHistory = [
-            trimmed,
-            ...(this.config.searchHistory ?? []).filter(q => q !== trimmed),
-        ].slice(0, 100);
-        this.save();
-    }
-    getSearchHistory() {
-        return this.config.searchHistory ?? [];
-    }
-    addFavorite(trackId) {
-        if (!this.config.favorites.includes(trackId)) {
-            this.config.favorites.push(trackId);
-            this.save();
-        }
-    }
-    removeFavorite(trackId) {
-        this.config.favorites = this.config.favorites.filter(id => id !== trackId);
-        this.save();
-    }
-    isFavorite(trackId) {
-        return this.config.favorites.includes(trackId);
-    }
-    getFavorites() {
-        return this.config.favorites;
-    }
-    setBackgroundPlaybackState(state) {
-        this.config.backgroundPlayback = {
-            enabled: true,
-            ipcPath: state.ipcPath,
-            currentUrl: state.currentUrl,
-            timestamp: new Date().toISOString(),
-        };
-        this.save();
-    }
-    getBackgroundPlaybackState() {
-        if (this.config.backgroundPlayback?.enabled) {
-            return {
-                enabled: true,
-                ipcPath: this.config.backgroundPlayback.ipcPath,
-                currentUrl: this.config.backgroundPlayback.currentUrl,
-                timestamp: this.config.backgroundPlayback.timestamp,
-            };
-        }
-        return { enabled: false };
-    }
-    clearBackgroundPlaybackState() {
-        this.config.backgroundPlayback = undefined;
-        this.save();
-    }
-    setLastVersionCheck(timestamp) {
-        this.config.lastVersionCheck = timestamp;
-        this.save();
-    }
-    getLastVersionCheck() {
-        return this.config.lastVersionCheck;
-    }
-}
-// Singleton instance
-let configServiceInstance = null;
-export function getConfigService() {
-    if (!configServiceInstance) {
-        configServiceInstance = new ConfigService();
-    }
-    return configServiceInstance;
-}