feat: Implement features and continuously optimize the proxy service

- Settings page UI
- Persist settings data
- Proxy server fixes & optimizations:
  - Fixed download latency caused by Range Seek
  - Improved cache stability
  - Implemented a dual-threading model to ensure smooth playback
- Optimized styles for the homepage TopBar and SideBar
- Added theme switching functionality
- Added theme color customization feature

electron/main.ts

@@ -4,8 +4,9 @@ import { fileURLToPath } from 'node:url'
 import path from 'node:path'
 import fs from 'node:fs'
 import { MpvController } from './mpvController'
-import { startProxyServer, cleanupCache } from './proxyServer'
+import { startProxyServer, cleanupCache, getCacheDir, getCacheSize, setPersistCache, clearCacheNow } from './proxyServer'
 import { PluginSystem } from '../src/main/pluginSystem.ts'
+import { loadSettings, saveSettings, getSetting, AppSettings } from './settingsStore'
 // @ts-ignore
 const require = createRequire(import.meta.url)
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
@@ -91,6 +92,55 @@ ipcMain.handle(
     }
 )
 
+// Cache IPC Handlers
+ipcMain.handle('cache:getInfo', () => {
+    const settings = loadSettings();
+    return {
+        path: getCacheDir(),
+        size: getCacheSize(),
+        persistCache: settings.persistCache
+    }
+})
+
+ipcMain.handle('cache:setPersist', (_, persist: boolean) => {
+    setPersistCache(persist)
+    saveSettings({ persistCache: persist })
+})
+
+ipcMain.handle('cache:openFolder', () => {
+    const dir = getCacheDir()
+    require('electron').shell.openPath(dir)
+})
+
+ipcMain.handle('cache:clear', () => {
+    clearCacheNow()
+})
+
+// Settings IPC Handlers
+ipcMain.handle('settings:getAll', () => {
+    return loadSettings()
+})
+
+ipcMain.handle('settings:set', (_, settings: Partial<AppSettings>) => {
+    return saveSettings(settings)
+})
+
+ipcMain.handle('settings:getTheme', () => {
+    return getSetting('theme')
+})
+
+ipcMain.handle('settings:setTheme', (_, theme: 'dark' | 'light') => {
+    saveSettings({ theme })
+})
+
+ipcMain.handle('settings:getAccentColor', () => {
+    return getSetting('accentColor')
+})
+
+ipcMain.handle('settings:setAccentColor', (_, color: string) => {
+    saveSettings({ accentColor: color })
+})
+
 app.on('window-all-closed', () => {
     if (process.platform !== 'darwin') {
         app.quit()

electron/preload.ts

@@ -22,5 +22,21 @@ contextBridge.exposeInMainWorld('electronAPI', {
     // Plugin System
     plugin: {
         call: (pluginId: string, method: string, args: any[]) => ipcRenderer.invoke('plugin:call', pluginId, method, args)
+    },
+
+    // Cache Control
+    getCacheInfo: () => ipcRenderer.invoke('cache:getInfo'),
+    setCachePersist: (persist: boolean) => ipcRenderer.invoke('cache:setPersist', persist),
+    openCacheFolder: () => ipcRenderer.invoke('cache:openFolder'),
+    clearCache: () => ipcRenderer.invoke('cache:clear'),
+
+    // Settings
+    settings: {
+        getAll: () => ipcRenderer.invoke('settings:getAll'),
+        set: (settings: any) => ipcRenderer.invoke('settings:set', settings),
+        getTheme: () => ipcRenderer.invoke('settings:getTheme'),
+        setTheme: (theme: 'dark' | 'light') => ipcRenderer.invoke('settings:setTheme', theme),
+        getAccentColor: () => ipcRenderer.invoke('settings:getAccentColor'),
+        setAccentColor: (color: string) => ipcRenderer.invoke('settings:setAccentColor', color)
     }
 })

electron/proxyServer.ts

@@ -36,14 +36,19 @@ interface CacheMetadata {
     createdAt: number;
 }
 
-// Memory cache for resolved URLs
-const urlCache = new Map<string, CacheEntry>();
-// Track in-progress downloads with their current size
-const downloadingFiles = new Map<string, {
+interface DownloadTask {
     currentSize: number;
     totalSize: number;
-    writeStream: fs.WriteStream | null;
-}>();
+    contentType: string;
+    abortController: AbortController | null;
+    promise: Promise<void> | null;
+}
+
+// Memory cache for resolved URLs
+const urlCache = new Map<string, CacheEntry>();
+
+// Track background download tasks
+const downloadTasks = new Map<string, DownloadTask>();
 
 function getCachePath(source: string, id: string, quality: string) {
     const dir = ensureCacheDir();
@@ -55,6 +60,10 @@ function getMetadataPath(cachePath: string): string {
     return cachePath + '.meta';
 }
 
+function getTempPath(cachePath: string): string {
+    return cachePath + '.tmp';
+}
+
 function readMetadata(cachePath: string): CacheMetadata | null {
     const metaPath = getMetadataPath(cachePath);
     try {
@@ -96,14 +105,16 @@ async function fetchFreshUrl(source: string, id: string, quality: string): Promi
 }
 
 function isValidCacheFile(filePath: string): boolean {
-    const metadata = readMetadata(filePath);
-    if (!metadata || !metadata.complete) return false;
+    try {
+        const metadata = readMetadata(filePath);
+        if (!metadata || !metadata.complete) return false;
+        if (!fs.existsSync(filePath)) return false;
 
-    if (!fs.existsSync(filePath)) return false;
-    const stat = fs.statSync(filePath);
-
-    // Verify the file size matches expected total
-    return stat.size === metadata.totalSize && stat.size > 1024;
+        const stat = fs.statSync(filePath);
+        return stat.size === metadata.totalSize && stat.size > 1024;
+    } catch {
+        return false;
+    }
 }
 
 function parseRangeHeader(range: string | undefined, fileSize: number): { start: number; end: number } | null {
@@ -122,81 +133,104 @@ function parseRangeHeader(range: string | undefined, fileSize: number): { start:
 }
 
 function serveFromCache(req: http.IncomingMessage, res: http.ServerResponse, filePath: string): boolean {
-    const metadata = readMetadata(filePath);
-    if (!metadata) {
-        console.warn('[Proxy] No metadata for cache file');
+    try {
+        const metadata = readMetadata(filePath);
+        if (!metadata) {
+            console.warn('[Proxy] No metadata for cache file');
+            return false;
+        }
+
+        const stat = fs.statSync(filePath);
+        const fileSize = stat.size;
+        const range = parseRangeHeader(req.headers.range, fileSize);
+
+        if (range) {
+            const { start, end } = range;
+            const chunksize = (end - start) + 1;
+
+            res.writeHead(206, {
+                'Content-Range': `bytes ${start}-${end}/${fileSize}`,
+                'Accept-Ranges': 'bytes',
+                'Content-Length': chunksize,
+                'Content-Type': metadata.contentType || 'audio/mpeg',
+            });
+
+            const file = fs.createReadStream(filePath, { start, end });
+            file.pipe(res);
+
+            file.on('error', (err) => {
+                console.error('[Proxy] Error reading cache file:', err);
+                if (!res.headersSent) {
+                    res.writeHead(500);
+                    res.end('Cache read error');
+                }
+            });
+        } else {
+            res.writeHead(200, {
+                'Content-Length': fileSize,
+                'Content-Type': metadata.contentType || 'audio/mpeg',
+                'Accept-Ranges': 'bytes',
+            });
+            const stream = fs.createReadStream(filePath);
+            stream.pipe(res);
+
+            stream.on('error', (err) => {
+                console.error('[Proxy] Error reading cache file:', err);
+            });
+        }
+        return true;
+    } catch (e) {
+        console.error('[Proxy] Error serving from cache:', e);
         return false;
     }
-
-    const stat = fs.statSync(filePath);
-    const fileSize = stat.size;
-    const range = parseRangeHeader(req.headers.range, fileSize);
-
-    if (range) {
-        const { start, end } = range;
-        const chunksize = (end - start) + 1;
-
-        res.writeHead(206, {
-            'Content-Range': `bytes ${start}-${end}/${fileSize}`,
-            'Accept-Ranges': 'bytes',
-            'Content-Length': chunksize,
-            'Content-Type': metadata.contentType || 'audio/mpeg',
-        });
-
-        const file = fs.createReadStream(filePath, { start, end });
-        file.pipe(res);
-
-        file.on('error', (err) => {
-            console.error('[Proxy] Error reading cache file:', err);
-            if (!res.headersSent) {
-                res.writeHead(500);
-                res.end('Cache read error');
-            }
-        });
-    } else {
-        res.writeHead(200, {
-            'Content-Length': fileSize,
-            'Content-Type': metadata.contentType || 'audio/mpeg',
-            'Accept-Ranges': 'bytes',
-        });
-        const stream = fs.createReadStream(filePath);
-        stream.pipe(res);
-
-        stream.on('error', (err) => {
-            console.error('[Proxy] Error reading cache file:', err);
-        });
-    }
-    return true;
 }
 
-async function proxyWithoutCache(
+/**
+ * 直接代理 Range 请求，不缓存（用于 seek 到未下载的位置）
+ */
+async function proxyRangeDirect(
     req: http.IncomingMessage,
     res: http.ServerResponse,
-    targetUrl: string
+    targetUrl: string,
+    totalSize: number,
+    contentType: string
 ): Promise<void> {
-    const headers: Record<string, string> = {};
+    const headers: Record<string, string> = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+    };
 
     if (req.headers.range) {
         headers['Range'] = req.headers.range;
     }
-    headers['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36';
 
     const response = await fetch(targetUrl, {
         method: 'GET',
         headers: headers,
     });
 
-    if (!response.ok) {
+    if (!response.ok && response.status !== 206) {
         throw { statusCode: response.status, statusText: response.statusText };
     }
 
-    const headersToForward = ['content-type', 'content-length', 'content-range', 'accept-ranges'];
-    headersToForward.forEach(h => {
-        const val = response.headers.get(h);
-        if (val) res.setHeader(h, val);
-    });
+    // Forward response headers
+    const responseContentType = response.headers.get('content-type') || contentType || 'audio/mpeg';
+    const contentLength = response.headers.get('content-length');
+    const contentRange = response.headers.get('content-range');
 
-    res.statusCode = response.status;
+    if (response.status === 206 && contentRange) {
+        res.writeHead(206, {
+            'Content-Type': responseContentType,
+            'Content-Length': contentLength || '',
+            'Content-Range': contentRange,
+            'Accept-Ranges': 'bytes',
+        });
+    } else {
+        res.writeHead(200, {
+            'Content-Type': responseContentType,
+            'Content-Length': contentLength || '',
+            'Accept-Ranges': 'bytes',
+        });
+    }
 
     if (!response.body) {
         res.end();
@@ -207,67 +241,259 @@ async function proxyWithoutCache(
     const nodeStream = Readable.fromWeb(response.body);
     nodeStream.pipe(res);
 
-    nodeStream.on('error', (err: Error) => {
-        console.error('[Proxy] Stream error:', err);
-        if (!res.headersSent) {
-            res.writeHead(502);
-            res.end('Proxy stream error');
-        }
+    return new Promise((resolve, reject) => {
+        nodeStream.on('end', resolve);
+        nodeStream.on('error', reject);
+        res.on('close', () => {
+            nodeStream.destroy();
+            resolve();
+        });
     });
 }
 
+/**
+ * 从部分下载的缓存中读取已下载的部分
+ */
+function serveFromPartialCache(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    filePath: string,
+    task: DownloadTask
+): boolean {
+    try {
+        const tempPath = getTempPath(filePath);
+        if (!fs.existsSync(tempPath)) return false;
+
+        const range = parseRangeHeader(req.headers.range, task.totalSize);
+        if (!range) return false;
+
+        const { start, end } = range;
+
+        // 检查请求的范围是否已下载
+        if (end >= task.currentSize) {
+            return false; // 还没下载到这里
+        }
+
+        const chunksize = (end - start) + 1;
+
+        res.writeHead(206, {
+            'Content-Range': `bytes ${start}-${end}/${task.totalSize}`,
+            'Accept-Ranges': 'bytes',
+            'Content-Length': chunksize,
+            'Content-Type': task.contentType || 'audio/mpeg',
+        });
+
+        const file = fs.createReadStream(tempPath, { start, end });
+        file.pipe(res);
+
+        return true;
+    } catch (e) {
+        console.error('[Proxy] Error serving from partial cache:', e);
+        return false;
+    }
+}
+
+/**
+ * 启动后台下载任务（不阻塞当前请求）
+ */
+function startBackgroundDownload(
+    targetUrl: string,
+    cacheFilePath: string,
+    cacheKey: string
+): DownloadTask {
+    const existingTask = downloadTasks.get(cacheFilePath);
+    if (existingTask) {
+        return existingTask;
+    }
+
+    const abortController = new AbortController();
+    const task: DownloadTask = {
+        currentSize: 0,
+        totalSize: 0,
+        contentType: 'audio/mpeg',
+        abortController,
+        promise: null,
+    };
+
+    downloadTasks.set(cacheFilePath, task);
+
+    task.promise = (async () => {
+        const tempPath = getTempPath(cacheFilePath);
+
+        try {
+            // 清理旧文件
+            try {
+                if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+            } catch { }
+
+            const response = await fetch(targetUrl, {
+                method: 'GET',
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+                },
+                signal: abortController.signal,
+            });
+
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+
+            const contentLength = parseInt(response.headers.get('content-length') || '0', 10);
+            const contentType = response.headers.get('content-type') || 'audio/mpeg';
+
+            if (!contentLength) {
+                console.warn('[Proxy] Background download: No content-length, skipping cache');
+                downloadTasks.delete(cacheFilePath);
+                return;
+            }
+
+            task.totalSize = contentLength;
+            task.contentType = contentType;
+
+            console.log(`[Proxy] Background download started: ${cacheFilePath} (${contentLength} bytes)`);
+
+            const fileStream = fs.createWriteStream(tempPath);
+
+            if (!response.body) {
+                downloadTasks.delete(cacheFilePath);
+                return;
+            }
+
+            // @ts-ignore
+            const nodeStream = Readable.fromWeb(response.body);
+
+            await new Promise<void>((resolve, reject) => {
+                nodeStream.on('data', (chunk: Buffer) => {
+                    task.currentSize += chunk.length;
+                });
+
+                nodeStream.pipe(fileStream);
+
+                fileStream.on('finish', () => {
+                    // 验证并移动文件
+                    try {
+                        const stat = fs.statSync(tempPath);
+                        if (stat.size === contentLength) {
+                            fs.renameSync(tempPath, cacheFilePath);
+                            writeMetadata(cacheFilePath, {
+                                totalSize: contentLength,
+                                contentType: contentType,
+                                complete: true,
+                                createdAt: Date.now()
+                            });
+                            console.log(`[Proxy] Background download complete: ${cacheFilePath}`);
+                        } else {
+                            console.warn(`[Proxy] Incomplete download: ${stat.size}/${contentLength}`);
+                            try { fs.unlinkSync(tempPath); } catch { }
+                        }
+                    } catch (e) {
+                        console.error('[Proxy] Failed to finalize cache:', e);
+                        try { fs.unlinkSync(tempPath); } catch { }
+                    }
+                    resolve();
+                });
+
+                fileStream.on('error', (err) => {
+                    console.error('[Proxy] Background download write error:', err);
+                    try { fs.unlinkSync(tempPath); } catch { }
+                    reject(err);
+                });
+
+                nodeStream.on('error', (err: Error) => {
+                    console.error('[Proxy] Background download stream error:', err);
+                    fileStream.destroy();
+                    try { fs.unlinkSync(tempPath); } catch { }
+                    reject(err);
+                });
+            });
+
+        } catch (e: any) {
+            if (e.name !== 'AbortError') {
+                console.error('[Proxy] Background download failed:', e);
+            }
+            try { fs.unlinkSync(tempPath); } catch { }
+        } finally {
+            downloadTasks.delete(cacheFilePath);
+        }
+    })();
+
+    return task;
+}
+
+/**
+ * 主代理函数 - 智能处理缓存和 Range 请求
+ */
 async function proxyAndCache(
     req: http.IncomingMessage,
     res: http.ServerResponse,
     targetUrl: string,
-    cacheFilePath: string
+    cacheFilePath: string,
+    cacheKey: string
 ): Promise<void> {
     const requestedRange = req.headers.range;
+    const isSeekRequest = requestedRange && !requestedRange.startsWith('bytes=0-');
 
-    // Check if already downloading
-    const downloadState = downloadingFiles.get(cacheFilePath);
-    if (downloadState) {
-        // Another request is already downloading this file
-        console.log(`[Proxy] File already downloading, current: ${downloadState.currentSize}/${downloadState.totalSize}`);
+    // 检查是否有正在进行的后台下载
+    let task = downloadTasks.get(cacheFilePath);
 
-        // For range requests, check if we can serve from partial cache
-        if (requestedRange) {
-            const range = parseRangeHeader(requestedRange, downloadState.totalSize);
-            if (range && range.end < downloadState.currentSize) {
-                // Requested range is fully downloaded, serve from cache
-                console.log(`[Proxy] Serving range from in-progress cache`);
+    if (task) {
+        console.log(`[Proxy] Download in progress: ${task.currentSize}/${task.totalSize}`);
 
-                const { start, end } = range;
-                const chunksize = (end - start) + 1;
+        // 尝试从部分缓存中读取
+        if (requestedRange && task.totalSize > 0) {
+            const range = parseRangeHeader(requestedRange, task.totalSize);
 
-                res.writeHead(206, {
-                    'Content-Range': `bytes ${start}-${end}/${downloadState.totalSize}`,
-                    'Accept-Ranges': 'bytes',
-                    'Content-Length': chunksize,
-                    'Content-Type': 'audio/mpeg',
-                });
+            if (range) {
+                // 检查请求的数据是否已下载
+                // 给一些缓冲区间（已下载部分的 95%）
+                const safeEnd = Math.floor(task.currentSize * 0.95);
 
-                const file = fs.createReadStream(cacheFilePath, { start, end });
-                file.pipe(res);
+                if (range.end < safeEnd && range.start < safeEnd) {
+                    console.log(`[Proxy] Serving range ${range.start}-${range.end} from partial cache (downloaded: ${task.currentSize})`);
+                    if (serveFromPartialCache(req, res, cacheFilePath, task)) {
+                        return;
+                    }
+                }
+
+                // 请求的数据还没下载到，直接代理这个 Range
+                console.log(`[Proxy] Range ${range.start}-${range.end} not cached yet (downloaded: ${task.currentSize}), proxying directly`);
+                await proxyRangeDirect(req, res, targetUrl, task.totalSize, task.contentType);
                 return;
             }
         }
 
-        // Can't serve from cache, proxy directly
-        await proxyWithoutCache(req, res, targetUrl);
+        // 无法确定如何处理，直接代理
+        await proxyRangeDirect(req, res, targetUrl, task.totalSize, task.contentType);
         return;
     }
 
-    // Check if this is a range request that doesn't start from 0
-    if (requestedRange && !requestedRange.startsWith('bytes=0-')) {
-        // This is a seek request - we need to fetch total size first
-        // then decide whether to start a full download or just proxy
-        console.log(`[Proxy] Range request without cache: ${requestedRange}`);
-        await proxyWithoutCache(req, res, targetUrl);
+    // 没有正在进行的下载任务
+
+    if (isSeekRequest) {
+        // Seek 请求：启动后台下载任务，同时直接代理当前请求
+        console.log(`[Proxy] Seek request: ${requestedRange}, starting background download`);
+
+        // 启动后台下载（不等待）
+        startBackgroundDownload(targetUrl, cacheFilePath, cacheKey);
+
+        // 获取文件信息用于正确的 Range 响应
+        const headResponse = await fetch(targetUrl, {
+            method: 'HEAD',
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            }
+        });
+
+        const totalSize = parseInt(headResponse.headers.get('content-length') || '0', 10);
+        const contentType = headResponse.headers.get('content-type') || 'audio/mpeg';
+
+        // 直接代理当前的 Range 请求
+        await proxyRangeDirect(req, res, targetUrl, totalSize, contentType);
         return;
     }
 
-    // Start a fresh download from the beginning
+    // 从头开始的请求：启动主下载任务并流式返回
+
     const headers: Record<string, string> = {
         'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
     };
@@ -286,8 +512,10 @@ async function proxyAndCache(
 
     if (!contentLength) {
         console.warn('[Proxy] No content-length, proxying without cache');
-        res.setHeader('Content-Type', contentType);
-        res.statusCode = 200;
+        res.writeHead(200, {
+            'Content-Type': contentType,
+            'Accept-Ranges': 'bytes',
+        });
 
         if (response.body) {
             // @ts-ignore
@@ -299,28 +527,29 @@ async function proxyAndCache(
         return;
     }
 
-    // Setup caching
-    const tempPath = cacheFilePath + '.tmp';
+    // 设置下载任务
+    const tempPath = getTempPath(cacheFilePath);
 
-    // Clean up any existing files
+    // 清理旧文件
     try {
         if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
         if (fs.existsSync(cacheFilePath)) fs.unlinkSync(cacheFilePath);
-    } catch (e) {
-        console.error('[Proxy] Cleanup error:', e);
-    }
+    } catch { }
 
     const fileStream = fs.createWriteStream(tempPath);
 
-    downloadingFiles.set(cacheFilePath, {
+    task = {
         currentSize: 0,
         totalSize: contentLength,
-        writeStream: fileStream
-    });
+        contentType: contentType,
+        abortController: null,
+        promise: null,
+    };
+    downloadTasks.set(cacheFilePath, task);
 
-    console.log(`[Proxy] Starting download: ${cacheFilePath} (${contentLength} bytes)`);
+    console.log(`[Proxy] Starting stream download: ${cacheFilePath} (${contentLength} bytes)`);
 
-    // Set response headers
+    // 发送响应头
     res.writeHead(200, {
         'Content-Length': contentLength,
         'Content-Type': contentType,
@@ -329,7 +558,7 @@ async function proxyAndCache(
 
     if (!response.body) {
         res.end();
-        downloadingFiles.delete(cacheFilePath);
+        downloadTasks.delete(cacheFilePath);
         return;
     }
 
@@ -337,26 +566,23 @@ async function proxyAndCache(
     const nodeStream = Readable.fromWeb(response.body);
     const passThrough = new PassThrough();
 
-    // Track download progress
-    let downloadedBytes = 0;
+    // 跟踪下载进度
     passThrough.on('data', (chunk: Buffer) => {
-        downloadedBytes += chunk.length;
-        const state = downloadingFiles.get(cacheFilePath);
-        if (state) {
-            state.currentSize = downloadedBytes;
+        if (task) {
+            task.currentSize += chunk.length;
         }
     });
 
-    // Pipe to client
+    // 流到客户端
     passThrough.pipe(res);
 
-    // Pipe to file
+    // 流到文件
     nodeStream.pipe(passThrough);
     nodeStream.pipe(fileStream);
 
-    // Handle completion
+    // 处理完成
     const cleanup = (success: boolean, error?: Error) => {
-        downloadingFiles.delete(cacheFilePath);
+        downloadTasks.delete(cacheFilePath);
 
         if (success && fs.existsSync(tempPath)) {
             try {
@@ -380,28 +606,104 @@ async function proxyAndCache(
             }
         } else if (!success) {
             console.error('[Proxy] Download failed:', error);
-            try { fs.unlinkSync(tempPath); } catch { }
+            // 不删除临时文件，让后续请求可以继续
         }
     };
 
     fileStream.on('finish', () => cleanup(true));
     fileStream.on('error', (err) => cleanup(false, err));
-    nodeStream.on('error', (err: Error) => cleanup(false, err));
+    nodeStream.on('error', (err: Error) => {
+        cleanup(false, err);
+        if (!res.headersSent) {
+            res.writeHead(502);
+            res.end('Proxy stream error');
+        }
+    });
 
-    // Handle client disconnect
+    // 客户端断开时不终止下载
     res.on('close', () => {
         if (!res.writableEnded) {
-            console.log('[Proxy] Client disconnected during download');
-            // Don't cleanup - let the download continue in background
+            console.log('[Proxy] Client disconnected, download continues in background');
         }
     });
 }
 
 let persistCacheEnabled = true;
 
+export function getCacheDir() {
+    return ensureCacheDir();
+}
+
+export function getCacheSize(): string {
+    const dir = ensureCacheDir();
+    if (!fs.existsSync(dir)) return '0 B';
+
+    let totalSize = 0;
+    try {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+            const filePath = path.join(dir, file);
+            try {
+                const stat = fs.statSync(filePath);
+                if (stat.isFile()) {
+                    totalSize += stat.size;
+                }
+            } catch { }
+        }
+    } catch (e) {
+        console.error('[Proxy] Error calculating cache size:', e);
+    }
+
+    if (totalSize < 1024) return `${totalSize} B`;
+    if (totalSize < 1024 * 1024) return `${(totalSize / 1024).toFixed(1)} KB`;
+    if (totalSize < 1024 * 1024 * 1024) return `${(totalSize / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(totalSize / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+
+export function isPersistCacheEnabled() {
+    return persistCacheEnabled;
+}
+
+export function setPersistCache(persist: boolean) {
+    persistCacheEnabled = persist;
+    console.log(`[Proxy] Cache persistence set to: ${persist}`);
+}
+
+export function clearCacheNow() {
+    const dir = ensureCacheDir();
+    if (fs.existsSync(dir)) {
+        console.log(`[Proxy] Clearing cache directory: ${dir}`);
+
+        // 终止所有下载任务
+        for (const [, task] of downloadTasks) {
+            if (task.abortController) {
+                task.abortController.abort();
+            }
+        }
+        downloadTasks.clear();
+
+        try {
+            fs.rmSync(dir, { recursive: true, force: true });
+            fs.mkdirSync(dir, { recursive: true });
+            console.log('[Proxy] Cache cleared');
+        } catch (e) {
+            console.error('[Proxy] Failed to clear cache:', e);
+        }
+    }
+}
+
 export function cleanupCache() {
     if (!persistCacheEnabled && CACHE_DIR && fs.existsSync(CACHE_DIR)) {
         console.log(`[Proxy] Cleaning up cache directory: ${CACHE_DIR}`);
+
+        // 终止所有下载任务
+        for (const [, task] of downloadTasks) {
+            if (task.abortController) {
+                task.abortController.abort();
+            }
+        }
+        downloadTasks.clear();
+
         try {
             fs.rmSync(CACHE_DIR, { recursive: true, force: true });
             console.log('[Proxy] Cache cleanup complete');
@@ -411,10 +713,44 @@ export function cleanupCache() {
     }
 }
 
+/**
+ * 清理过期的临时文件
+ */
+function cleanupTempFiles() {
+    const dir = ensureCacheDir();
+    try {
+        const files = fs.readdirSync(dir);
+        const now = Date.now();
+
+        for (const file of files) {
+            if (file.endsWith('.tmp')) {
+                const filePath = path.join(dir, file);
+                const cacheFilePath = filePath.replace('.tmp', '');
+
+                // 如果没有正在下载这个文件，且临时文件超过 1 小时，删除它
+                if (!downloadTasks.has(cacheFilePath)) {
+                    try {
+                        const stat = fs.statSync(filePath);
+                        if (now - stat.mtimeMs > 3600 * 1000) {
+                            fs.unlinkSync(filePath);
+                            console.log(`[Proxy] Cleaned up stale temp file: ${file}`);
+                        }
+                    } catch { }
+                }
+            }
+        }
+    } catch (e) {
+        console.error('[Proxy] Error cleaning up temp files:', e);
+    }
+}
+
 export function startProxyServer(persistCache: boolean = true) {
     persistCacheEnabled = persistCache;
     console.log(`[Proxy] Persist cache: ${persistCache}`);
 
+    // 定期清理临时文件
+    setInterval(cleanupTempFiles, 30 * 60 * 1000); // 每 30 分钟
+
     const server = http.createServer(async (req, res) => {
         res.setHeader('Access-Control-Allow-Origin', '*');
         res.setHeader('Access-Control-Allow-Methods', 'GET, HEAD, OPTIONS');
@@ -426,7 +762,6 @@ export function startProxyServer(persistCache: boolean = true) {
             return;
         }
 
-        // Handle HEAD requests for range support detection
         if (req.method === 'HEAD') {
             res.setHeader('Accept-Ranges', 'bytes');
             res.statusCode = 200;
@@ -455,13 +790,13 @@ export function startProxyServer(persistCache: boolean = true) {
             const cacheKey = `${source}:${id}:${quality}`;
             const cacheFilePath = getCachePath(source, id, quality);
 
-            // 1. Check complete disk cache
+            // 1. 检查完整缓存
             if (isValidCacheFile(cacheFilePath)) {
                 console.log(`[Proxy] Serving from complete cache: ${cacheFilePath}`);
                 const success = serveFromCache(req, res, cacheFilePath);
                 if (success) return;
 
-                // Cache invalid, clean up
+                // 缓存无效，清理
                 console.warn('[Proxy] Cache file invalid, cleaning up...');
                 try {
                     fs.unlinkSync(cacheFilePath);
@@ -469,7 +804,7 @@ export function startProxyServer(persistCache: boolean = true) {
                 } catch { }
             }
 
-            // 2. Resolve URL
+            // 2. 解析 URL
             let playUrl: string | null = null;
             const memCached = urlCache.get(cacheKey);
             if (memCached && Date.now() < memCached.expiresAt) {
@@ -487,14 +822,42 @@ export function startProxyServer(persistCache: boolean = true) {
                 return;
             }
 
-            // 3. Proxy & Cache
-            try {
-                await proxyAndCache(req, res, playUrl, cacheFilePath);
-            } catch (e: any) {
-                console.warn(`[Proxy] Proxy error:`, e);
-                if (!res.headersSent) {
-                    res.writeHead(e.statusCode || 502);
-                    res.end('Proxy Error');
+            // 3. 代理和缓存
+            const maxAttempts = 3;
+            let currentAttempt = 0;
+            let lastError: any = null;
+
+            while (currentAttempt < maxAttempts) {
+                try {
+                    await proxyAndCache(req, res, playUrl, cacheFilePath, cacheKey);
+                    break;
+                } catch (e: any) {
+                    lastError = e;
+                    currentAttempt++;
+                    console.warn(`[Proxy] Proxy error (Attempt ${currentAttempt}/${maxAttempts}):`, e);
+
+                    if (currentAttempt < maxAttempts) {
+                        console.log('[Proxy] Error occurred, refreshing URL from plugin...');
+
+                        // 清除 URL 缓存
+                        urlCache.delete(cacheKey);
+
+                        // 获取新 URL
+                        const newUrl = await fetchFreshUrl(source, id, quality);
+                        if (newUrl) {
+                            playUrl = newUrl;
+                            continue;
+                        } else {
+                            console.error('[Proxy] Failed to refresh URL');
+                        }
+                    }
+
+                    // 发送错误响应
+                    if (!res.headersSent) {
+                        res.writeHead(lastError?.statusCode || 502);
+                        res.end('Proxy Error');
+                    }
+                    break;
                 }
             }
 
@@ -509,6 +872,7 @@ export function startProxyServer(persistCache: boolean = true) {
 
     server.listen(PORT, '127.0.0.1', () => {
         ensureCacheDir();
+        cleanupTempFiles(); // 启动时清理
         console.log(`[Proxy] Server running at http://127.0.0.1:${PORT}/music`);
         console.log(`[Proxy] Cache dir: ${CACHE_DIR}`);
     });

electron/settingsStore.ts

@@ -0,0 +1,65 @@
+import fs from 'fs';
+import path from 'path';
+import { app } from 'electron';
+
+export interface AppSettings {
+    // Cache
+    persistCache: boolean;
+
+    // Appearance
+    theme: 'dark' | 'light';
+    accentColor: string;
+}
+
+const DEFAULT_SETTINGS: AppSettings = {
+    persistCache: true,
+    theme: 'dark',
+    accentColor: '#ec4141', // Default red
+};
+
+let settingsCache: AppSettings | null = null;
+
+function getSettingsPath(): string {
+    return path.join(app.getPath('userData'), 'settings.json');
+}
+
+export function loadSettings(): AppSettings {
+    if (settingsCache) return settingsCache;
+
+    const settingsPath = getSettingsPath();
+    try {
+        if (fs.existsSync(settingsPath)) {
+            const data = fs.readFileSync(settingsPath, 'utf-8');
+            settingsCache = { ...DEFAULT_SETTINGS, ...JSON.parse(data) };
+            console.log('[Settings] Loaded from disk:', settingsCache);
+            return settingsCache!;
+        }
+    } catch (e) {
+        console.error('[Settings] Failed to load settings:', e);
+    }
+
+    settingsCache = { ...DEFAULT_SETTINGS };
+    return settingsCache;
+}
+
+export function saveSettings(settings: Partial<AppSettings>): AppSettings {
+    settingsCache = { ...loadSettings(), ...settings };
+
+    const settingsPath = getSettingsPath();
+    try {
+        fs.writeFileSync(settingsPath, JSON.stringify(settingsCache, null, 2));
+        console.log('[Settings] Saved to disk:', settingsCache);
+    } catch (e) {
+        console.error('[Settings] Failed to save settings:', e);
+    }
+
+    return settingsCache;
+}
+
+export function getSetting<K extends keyof AppSettings>(key: K): AppSettings[K] {
+    return loadSettings()[key];
+}
+
+export function setSetting<K extends keyof AppSettings>(key: K, value: AppSettings[K]): void {
+    saveSettings({ [key]: value });
+}