@involvex/youtube-music-cli 0.0.46 → 0.0.48

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

@@ -1,215 +0,0 @@
-import { getPluginLoaderService } from "./plugin-loader.service.js";
-import { getPluginPermissionsService } from "./plugin-permissions.service.js";
-import { getConfigService } from "../config/config.service.js";
-import { logger } from "../logger/logger.service.js";
-import { CONFIG_DIR } from "../../utils/constants.js";
-import { join } from 'node:path';
-import { existsSync, readdirSync } from 'node:fs';
-const PLUGINS_DIR = join(CONFIG_DIR, 'plugins');
-/**
- * Plugin registry service - manages all loaded plugins
- */
-class PluginRegistryService {
-    plugins;
-    pluginLoader = getPluginLoaderService();
-    permissionsService = getPluginPermissionsService();
-    configService = getConfigService();
-    constructor() {
-        this.plugins = new Map();
-    }
-    /**
-     * Load a plugin from a directory
-     */
-    async loadPlugin(pluginPath) {
-        const instance = await this.pluginLoader.loadPlugin(pluginPath);
-        // Check if already loaded
-        if (this.plugins.has(instance.manifest.id)) {
-            throw new Error(`Plugin ${instance.manifest.id} is already loaded`);
-        }
-        // Store in registry
-        this.plugins.set(instance.manifest.id, instance);
-        logger.info('PluginRegistryService', `Registered plugin: ${instance.manifest.name}`);
-        return instance;
-    }
-    /**
-     * Unload a plugin
-     */
-    async unloadPlugin(pluginId) {
-        const instance = this.plugins.get(pluginId);
-        if (!instance) {
-            throw new Error(`Plugin ${pluginId} is not loaded`);
-        }
-        // Call destroy hook if enabled
-        if (instance.enabled && instance.plugin.destroy) {
-            try {
-                await this.pluginLoader.callHook(instance.plugin, 'destroy', instance.context);
-            }
-            catch (error) {
-                logger.error('PluginRegistryService', `Error destroying plugin ${pluginId}:`, error);
-            }
-        }
-        // Remove from registry
-        this.plugins.delete(pluginId);
-        logger.info('PluginRegistryService', `Unloaded plugin: ${pluginId}`);
-    }
-    /**
-     * Enable a plugin
-     */
-    async enablePlugin(pluginId) {
-        const instance = this.plugins.get(pluginId);
-        if (!instance) {
-            throw new Error(`Plugin ${pluginId} is not loaded`);
-        }
-        if (instance.enabled) {
-            logger.debug('PluginRegistryService', `Plugin ${pluginId} is already enabled`);
-            return;
-        }
-        // Call enable hook
-        if (instance.plugin.enable) {
-            await this.pluginLoader.callHook(instance.plugin, 'enable', instance.context);
-        }
-        instance.enabled = true;
-        instance.config.enabled = true;
-        this.savePluginState();
-        logger.info('PluginRegistryService', `Enabled plugin: ${pluginId}`);
-    }
-    /**
-     * Disable a plugin
-     */
-    async disablePlugin(pluginId) {
-        const instance = this.plugins.get(pluginId);
-        if (!instance) {
-            throw new Error(`Plugin ${pluginId} is not loaded`);
-        }
-        if (!instance.enabled) {
-            logger.debug('PluginRegistryService', `Plugin ${pluginId} is already disabled`);
-            return;
-        }
-        // Call disable hook
-        if (instance.plugin.disable) {
-            await this.pluginLoader.callHook(instance.plugin, 'disable', instance.context);
-        }
-        instance.enabled = false;
-        instance.config.enabled = false;
-        this.savePluginState();
-        logger.info('PluginRegistryService', `Disabled plugin: ${pluginId}`);
-    }
-    /**
-     * Get a plugin instance
-     */
-    getPlugin(pluginId) {
-        return this.plugins.get(pluginId);
-    }
-    /**
-     * Get all plugins
-     */
-    getAllPlugins() {
-        return [...this.plugins.values()];
-    }
-    /**
-     * Get enabled plugins
-     */
-    getEnabledPlugins() {
-        return this.getAllPlugins().filter(p => p.enabled);
-    }
-    /**
-     * Check if a plugin is loaded
-     */
-    isLoaded(pluginId) {
-        return this.plugins.has(pluginId);
-    }
-    /**
-     * Check if a plugin is enabled
-     */
-    isEnabled(pluginId) {
-        const plugin = this.plugins.get(pluginId);
-        return plugin?.enabled ?? false;
-    }
-    /**
-     * Get plugin permissions
-     */
-    getPermissions(pluginId) {
-        return this.permissionsService.getPermissions(pluginId);
-    }
-    /**
-     * Load all plugins from the plugins directory
-     */
-    async loadAllPlugins() {
-        if (!existsSync(PLUGINS_DIR)) {
-            logger.info('PluginRegistryService', 'Plugins directory does not exist, skipping plugin loading');
-            return;
-        }
-        const entries = readdirSync(PLUGINS_DIR, { withFileTypes: true });
-        const pluginDirs = entries
-            .filter(entry => entry.isDirectory())
-            .map(entry => join(PLUGINS_DIR, entry.name));
-        logger.info('PluginRegistryService', `Found ${pluginDirs.length} potential plugin(s)`);
-        for (const pluginDir of pluginDirs) {
-            try {
-                const instance = await this.loadPlugin(pluginDir);
-                // Check if plugin was previously enabled
-                const savedState = this.getSavedPluginState(instance.manifest.id);
-                if (savedState?.enabled) {
-                    await this.enablePlugin(instance.manifest.id);
-                }
-            }
-            catch (error) {
-                logger.error('PluginRegistryService', `Failed to load plugin from ${pluginDir}:`, error);
-            }
-        }
-        logger.info('PluginRegistryService', `Loaded ${this.plugins.size} plugin(s)`);
-    }
-    /**
-     * Save plugin enabled/disabled state to config
-     */
-    savePluginState() {
-        const pluginStates = {};
-        for (const [id, instance] of this.plugins) {
-            pluginStates[id] = { enabled: instance.enabled };
-        }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.configService.set('pluginStates', pluginStates);
-    }
-    /**
-     * Get saved plugin state from config
-     */
-    getSavedPluginState(pluginId) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const states = this.configService.get('pluginStates');
-        return states?.[pluginId];
-    }
-    /**
-     * Clear all plugins
-     */
-    async unloadAllPlugins() {
-        const pluginIds = [...this.plugins.keys()];
-        for (const pluginId of pluginIds) {
-            try {
-                await this.unloadPlugin(pluginId);
-            }
-            catch (error) {
-                logger.error('PluginRegistryService', `Error unloading plugin ${pluginId}:`, error);
-            }
-        }
-    }
-}
-// Singleton instance
-let instance = null;
-/**
- * Get the plugin registry service singleton
- */
-export function getPluginRegistryService() {
-    if (!instance) {
-        instance = new PluginRegistryService();
-    }
-    return instance;
-}
-/**
- * Reset the singleton (for testing)
- */
-export function resetPluginRegistryService() {
-    if (instance) {
-        void instance.unloadAllPlugins();
-    }
-    instance = null;
-}

package/dist/source/services/plugin/plugin-ui-api.js

@@ -1,46 +0,0 @@
-import { logger } from "../logger/logger.service.js";
-// Registry for plugin views
-const pluginViews = new Map();
-/**
- * Register a plugin view
- */
-export function registerPluginView(viewId, component) {
-    if (pluginViews.has(viewId)) {
-        logger.warn('PluginUIAPI', `View ${viewId} is already registered`);
-        return;
-    }
-    pluginViews.set(viewId, component);
-    logger.info('PluginUIAPI', `Registered view: ${viewId}`);
-}
-/**
- * Unregister a plugin view
- */
-export function unregisterPluginView(viewId) {
-    pluginViews.delete(viewId);
-    logger.info('PluginUIAPI', `Unregistered view: ${viewId}`);
-}
-/**
- * Get a plugin view by ID
- */
-export function getPluginView(viewId) {
-    return pluginViews.get(viewId);
-}
-/**
- * Check if a plugin view exists
- */
-export function hasPluginView(viewId) {
-    return pluginViews.has(viewId);
-}
-/**
- * Get all registered plugin views
- */
-export function getAllPluginViews() {
-    return new Map(pluginViews);
-}
-/**
- * Clear all plugin views (for cleanup)
- */
-export function clearAllPluginViews() {
-    pluginViews.clear();
-    logger.info('PluginUIAPI', 'Cleared all plugin views');
-}

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

@@ -1,206 +0,0 @@
-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/scrobbling/scrobbling.service.js

@@ -1,115 +0,0 @@
-// 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('sha256')
-        .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.js

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