@involvex/youtube-music-cli 0.0.46 → 0.0.48

package/dist/source/services/version-check/version-check.service.js

@@ -1,121 +0,0 @@
-// Version check service for npm registry updates
-import { APP_NAME, APP_VERSION } from "../../utils/constants.js";
-import { logger } from "../logger/logger.service.js";
-class VersionCheckService {
-    static instance;
-    NPM_REGISTRY_URL = 'https://registry.npmjs.org';
-    CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
-    constructor() { }
-    static getInstance() {
-        if (!VersionCheckService.instance) {
-            VersionCheckService.instance = new VersionCheckService();
-        }
-        return VersionCheckService.instance;
-    }
-    /**
-     * Compare two semantic version strings
-     * Returns: 1 if a > b, -1 if a < b, 0 if equal
-     */
-    compareVersions(a, b) {
-        const parseVersion = (v) => {
-            // Remove 'v' prefix if present and split by non-numeric chars
-            const clean = v.replace(/^v/i, '');
-            return clean.split(/[.-]/).map(part => {
-                const num = parseInt(part, 10);
-                return Number.isNaN(num) ? 0 : num;
-            });
-        };
-        const partsA = parseVersion(a);
-        const partsB = parseVersion(b);
-        const maxLength = Math.max(partsA.length, partsB.length);
-        for (let i = 0; i < maxLength; i++) {
-            const partA = partsA[i] ?? 0;
-            const partB = partsB[i] ?? 0;
-            if (partA > partB)
-                return 1;
-            if (partA < partB)
-                return -1;
-        }
-        return 0;
-    }
-    /**
-     * Check if a version check should be performed (once per 24 hours)
-     */
-    shouldCheck(lastCheck) {
-        if (!lastCheck)
-            return true;
-        try {
-            const lastCheckDate = new Date(lastCheck);
-            const now = new Date();
-            const diff = now.getTime() - lastCheckDate.getTime();
-            return diff >= this.CHECK_INTERVAL;
-        }
-        catch {
-            return true;
-        }
-    }
-    /**
-     * Mark that a version check has been performed
-     * Returns the timestamp string to store
-     */
-    markChecked() {
-        return new Date().toISOString();
-    }
-    /**
-     * Check npm registry for available updates
-     */
-    async checkForUpdates(currentVersion = APP_VERSION) {
-        try {
-            logger.debug('VersionCheckService', 'Checking for updates', {
-                package: APP_NAME,
-                currentVersion,
-            });
-            const url = `${this.NPM_REGISTRY_URL}/${APP_NAME}`;
-            const response = await fetch(url, {
-                signal: AbortSignal.timeout(5000), // 5 second timeout
-            });
-            if (!response.ok) {
-                logger.warn('VersionCheckService', 'Failed to fetch package info', {
-                    status: response.status,
-                });
-                return {
-                    hasUpdate: false,
-                    currentVersion,
-                    latestVersion: currentVersion,
-                };
-            }
-            const data = (await response.json());
-            const latestVersion = data['dist-tags']?.latest;
-            if (!latestVersion) {
-                logger.warn('VersionCheckService', 'No latest version found in response');
-                return {
-                    hasUpdate: false,
-                    currentVersion,
-                    latestVersion: currentVersion,
-                };
-            }
-            const hasUpdate = this.compareVersions(latestVersion, currentVersion) > 0;
-            logger.info('VersionCheckService', 'Version check complete', {
-                currentVersion,
-                latestVersion,
-                hasUpdate,
-            });
-            return {
-                hasUpdate,
-                currentVersion,
-                latestVersion,
-            };
-        }
-        catch (error) {
-            logger.error('VersionCheckService', 'Error checking for updates', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                hasUpdate: false,
-                currentVersion,
-                latestVersion: currentVersion,
-            };
-        }
-    }
-}
-export const getVersionCheckService = () => VersionCheckService.getInstance();

package/dist/source/services/web/static-file.service.js

@@ -1,185 +0,0 @@
-// Static file serving service for web UI
-import { readFile } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { extname, join, dirname, normalize, resolve, sep } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { logger } from "../logger/logger.service.js";
-const MIME_TYPES = {
-    '.html': 'text/html',
-    '.css': 'text/css',
-    '.js': 'text/javascript',
-    '.json': 'application/json',
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.gif': 'image/gif',
-    '.svg': 'image/svg+xml',
-    '.ico': 'image/x-icon',
-    '.woff': 'font/woff',
-    '.woff2': 'font/woff2',
-    '.ttf': 'font/ttf',
-    '.eot': 'application/vnd.ms-fontobject',
-};
-class StaticFileService {
-    webDistDir;
-    indexHtml = null;
-    indexHtmlLoaded = false;
-    constructor() {
-        // Web UI is built to dist/web/ relative to the project root
-        // Get the directory of the current file
-        const currentFile = fileURLToPath(import.meta.url);
-        const currentDir = dirname(currentFile);
-        // Detect if running from dist/ or source/
-        // dist/source/services/web -> need to go up 4 levels to reach project root
-        // source/services/web -> need to go up 3 levels to reach project root
-        const isDist = currentFile.includes('/dist/') || currentFile.includes('\\dist\\');
-        let projectRoot;
-        if (isDist) {
-            // dist/source/services/web -> services/web -> services -> source -> dist -> project root
-            projectRoot = join(currentDir, '..', '..', '..', '..');
-        }
-        else {
-            // source/services/web -> services/web -> services -> source -> project root
-            projectRoot = join(currentDir, '..', '..', '..');
-        }
-        this.webDistDir = join(projectRoot, 'dist', 'web');
-        logger.debug('StaticFileService', 'Path resolved', {
-            webDistDir: this.webDistDir,
-            exists: existsSync(this.webDistDir),
-        });
-    }
-    /**
-     * Get MIME type for a file extension
-     */
-    getMimeType(filePath) {
-        const ext = extname(filePath).toLowerCase();
-        return MIME_TYPES[ext] || 'application/octet-stream';
-    }
-    resolveSafeFilePath(urlPath) {
-        let decodedPath;
-        try {
-            decodedPath = decodeURIComponent(urlPath);
-        }
-        catch {
-            return null;
-        }
-        const relativePath = normalize(decodedPath).replace(/^[\\/]+/, '');
-        const rootPath = resolve(this.webDistDir);
-        const resolvedPath = resolve(rootPath, relativePath);
-        const rootPrefix = rootPath.endsWith(sep) ? rootPath : `${rootPath}${sep}`;
-        if (resolvedPath !== rootPath && !resolvedPath.startsWith(rootPrefix)) {
-            return null;
-        }
-        return resolvedPath;
-    }
-    /**
-     * Load index.html into memory
-     */
-    async loadIndexHtml() {
-        if (this.indexHtmlLoaded)
-            return;
-        const indexPath = join(this.webDistDir, 'index.html');
-        try {
-            const buffer = await readFile(indexPath);
-            this.indexHtml = buffer.toString('utf-8');
-            this.indexHtmlLoaded = true;
-            logger.info('StaticFileService', 'index.html loaded');
-        }
-        catch (error) {
-            logger.error('StaticFileService', 'Failed to load index.html', {
-                indexPath,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    /**
-     * Serve a static file
-     */
-    async serve(url, _req, res) {
-        // Remove query string
-        const urlPath = url.split('?')[0] ?? '/';
-        // Serve index.html for SPA routes
-        if (urlPath === '/' || !urlPath.includes('.')) {
-            // Ensure index.html is loaded
-            if (!this.indexHtmlLoaded) {
-                await this.loadIndexHtml();
-            }
-            if (this.indexHtml) {
-                res.writeHead(200, {
-                    'Content-Type': 'text/html',
-                    'Cache-Control': 'public, max-age=3600',
-                });
-                res.end(this.indexHtml);
-            }
-            else {
-                // Web UI not built, serve a simple message
-                res.writeHead(503, { 'Content-Type': 'text/html' });
-                res.end(`
-					<!DOCTYPE html>
-					<html>
-					<head><title>Web UI Not Built</title></head>
-					<body>
-						<h1>Web UI Not Built</h1>
-						<p>Run <code>bun run build:web</code> to build the web UI.</p>
-					</body>
-					</html>
-				`);
-            }
-            return;
-        }
-        // Serve static files
-        const filePath = this.resolveSafeFilePath(urlPath);
-        if (!filePath) {
-            res.writeHead(400, { 'Content-Type': 'text/plain' });
-            res.end('Bad Request');
-            return;
-        }
-        try {
-            // Check if file exists
-            if (!existsSync(filePath)) {
-                res.writeHead(404, { 'Content-Type': 'text/plain' });
-                res.end('Not Found');
-                return;
-            }
-            // Read and serve file
-            const content = await readFile(filePath);
-            const mimeType = this.getMimeType(filePath);
-            res.writeHead(200, {
-                'Content-Type': mimeType,
-                'Cache-Control': 'public, max-age=86400', // 1 day
-            });
-            res.end(content);
-        }
-        catch (error) {
-            logger.error('StaticFileService', 'Failed to serve file', {
-                filePath,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            res.writeHead(500, { 'Content-Type': 'text/plain' });
-            res.end('Internal Server Error');
-        }
-    }
-    /**
-     * Check if web UI is built
-     */
-    isWebUiBuilt() {
-        const indexPath = join(this.webDistDir, 'index.html');
-        return existsSync(indexPath);
-    }
-    /**
-     * Clear cached index.html (useful for development)
-     */
-    clearCache() {
-        this.indexHtml = null;
-        this.indexHtmlLoaded = false;
-        logger.debug('StaticFileService', 'Cache cleared');
-    }
-}
-// Singleton instance
-let staticFileServiceInstance = null;
-export function getStaticFileService() {
-    if (!staticFileServiceInstance) {
-        staticFileServiceInstance = new StaticFileService();
-    }
-    return staticFileServiceInstance;
-}