@lynker-desktop/electron-sdk 0.0.9-alpha.50 → 0.0.9-alpha.52

package/main/index.js

@@ -3,9 +3,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 const fs = require('node:fs');
 const path = require('node:path');
 const node_util = require('node:util');
-const http = require('node:http');
-const https = require('node:https');
-const node_child_process = require('node:child_process');
 const electron = require('electron');
 const md5 = require('md5');
 const uuid = require('uuid');
@@ -17,6 +14,8 @@ const windowManager = require('@lynker-desktop/electron-window-manager/main');
 const index$1 = require('../common/index.js');
 const store = require('./store.js');
 const clipboard = require('./clipboard.js');
+const resourceCache = require('./resource-cache.js');
+const videoDownloader = require('./video-downloader.js');
 
 function _interopNamespaceDefault(e) {
     const n = Object.create(null);
@@ -70,7 +69,7 @@ const initialize = (options) => {
     store.initializeStore();
     clipboard.initializeClipboard();
     if (options.ffmpegPath) {
-        VideoDownloader.getInstance().setFFmpegPath(options.ffmpegPath);
+        videoDownloader.setFFmpegPath(options.ffmpegPath);
     }
     const wm = windowManager__namespace.initialize(preload, loadingViewUrl, errorViewUrl, preloadWebContentsConfig, webviewDomainWhiteList || []);
     if (protocol) {
@@ -82,7 +81,7 @@ const initialize = (options) => {
     if (resourceCacheOptions) {
         if (resourceCacheOptions.cacheDir) {
             serveOptions.push({
-                scheme: ResourceCache.scheme,
+                scheme: resourceCache.ResourceCache.scheme,
                 directory: resourceCacheOptions.cacheDir,
             });
         }
@@ -92,7 +91,7 @@ const initialize = (options) => {
     }
     if (resourceCacheOptions) {
         electron.app.on('ready', () => {
-            new ResourceCache(electron.session.defaultSession, resourceCacheOptions);
+            new resourceCache.ResourceCache(electron.session.defaultSession, resourceCacheOptions);
         });
     }
     class SDK {
@@ -100,10 +99,10 @@ const initialize = (options) => {
     SDK.ipc = ipc__namespace.mainIPC;
     SDK.windowManager = wm;
     SDK.getPreload = () => preload;
-    SDK.downloadVideo = downloadVideo;
-    SDK.clearVideoCache = clearVideoCache;
-    SDK.getVideoCacheStats = getVideoCacheStats;
-    SDK.removeVideoCache = removeVideoCache;
+    SDK.downloadVideo = videoDownloader.downloadVideo;
+    SDK.clearVideoCache = videoDownloader.clearVideoCache;
+    SDK.getVideoCacheStats = videoDownloader.getVideoCacheStats;
+    SDK.removeVideoCache = videoDownloader.removeVideoCache;
     ipc__namespace.mainIPC.handleRenderer(index$1.IPC_GET_APP_METRICS, async () => {
         const metrics = electron.app.getAppMetrics().map(i => {
             const webContents = findWebContentsByPid(i.pid || 0);
@@ -118,7 +117,7 @@ const initialize = (options) => {
     });
     ipc__namespace.mainIPC.handleRenderer(`__sdk_transcode_video__`, async (options) => {
         const md5Options = md5(JSON.stringify(options.url));
-        downloadVideo(options, {
+        videoDownloader.downloadVideo(options, {
             onDownloadProgress: (progress) => {
                 ipc__namespace.mainIPC.invokeAllRenderer(`__sdk_transcode_video_callback_${md5Options}__`, {
                     type: 'downloadProgress',
@@ -296,231 +295,12 @@ const serve = (options) => {
         }
     });
 };
-/**
- * 默认配置
- */
-const DEFAULT_OPTIONS = {
-    cacheDir: '',
-    cacheTTL: 24 * 60 * 60 * 1000,
-    match: /\.(png|jpe?g|webp|gif|svg|woff2?|ttf|mp4|webm|ogg|css|js)(\?.*)?$/i,
-    allowedOrigins: null,
-};
-/**
- * 资源缓存类：拦截并缓存静态资源，提升加载性能
- */
-class ResourceCache {
-    /**
-     * 构造函数
-     * @param session Electron session
-     * @param options 缓存配置
-     */
-    constructor(session, options) {
-        this.cacheHost = `${ResourceCache.scheme}://-`;
-        if (!session)
-            throw new Error('ResourceCache: session is required');
-        this.session = session;
-        // 合并配置，保证类型安全
-        this.options = {
-            ...DEFAULT_OPTIONS,
-            ...options,
-            cacheDir: options.cacheDir,
-            cacheTTL: options.cacheTTL ?? DEFAULT_OPTIONS.cacheTTL,
-            match: options.match ?? DEFAULT_OPTIONS.match,
-            allowedOrigins: options.allowedOrigins ?? DEFAULT_OPTIONS.allowedOrigins,
-        };
-        if (!this.options.cacheDir) {
-            throw new Error('ResourceCache: cacheDir is required');
-        }
-        // 确保缓存目录存在
-        if (!fs.existsSync(this.options.cacheDir)) {
-            fs.mkdirSync(this.options.cacheDir, { recursive: true });
-        }
-        this._registerInterceptor();
-        this._cleanOldCache();
-    }
-    /**
-     * 获取资源匹配函数
-     */
-    _getMatchFunction() {
-        const matcher = this.options.match;
-        if (typeof matcher === 'function')
-            return matcher;
-        if (matcher instanceof RegExp)
-            return (url) => matcher.test(url);
-        return () => false;
-    }
-    /**
-     * 获取来源校验函数
-     */
-    _getOriginAllowFunction() {
-        const origins = this.options.allowedOrigins;
-        if (!origins)
-            return () => true;
-        if (typeof origins === 'function')
-            return origins;
-        const prefixList = origins.map(o => o.toLowerCase());
-        return (url) => {
-            try {
-                const origin = new URL(url).origin.toLowerCase();
-                return prefixList.some(prefix => origin.startsWith(prefix));
-            }
-            catch {
-                return false;
-            }
-        };
-    }
-    /**
-     * 获取缓存文件路径
-     * @param url 资源URL
-     */
-    getCachedPath(url) {
-        const md5Str = md5(url);
-        const urlObj = new URL(url);
-        // 取文件扩展名，若无则用 .res
-        const ext = path.extname(urlObj.pathname) || '.res';
-        return {
-            filePath: path.join(this.options.cacheDir, `${md5Str}${ext}`),
-            hostPath: `${this.cacheHost}/${md5Str}${ext}`,
-        };
-    }
-    /**
-     * 判断缓存是否有效
-     * @param filePath 缓存文件路径
-     */
-    isCacheValid(filePath) {
-        if (!fs.existsSync(filePath))
-            return false;
-        const stat = fs.statSync(filePath);
-        return Date.now() - stat.mtimeMs < this.options.cacheTTL;
-    }
-    /**
-     * 下载资源到本地缓存
-     * @param url 资源URL
-     * @param filePath 本地缓存路径
-     */
-    downloadResource(url, filePath) {
-        const tempFilePath = `${filePath}.cache`;
-        const lib = url.startsWith('https') ? https : http;
-        const file = fs.createWriteStream(tempFilePath);
-        let request;
-        const cleanupAndAbort = (errMsg, err) => {
-            if (err) {
-                console.log(errMsg, err);
-            }
-            else {
-                console.log(errMsg);
-            }
-            if (request) {
-                request.destroy();
-            }
-            file.close(() => {
-                // 使用 existsSync 避免在文件不存在时 unlink 抛出错误
-                if (fs.existsSync(tempFilePath)) {
-                    fs.unlink(tempFilePath, () => { });
-                }
-            });
-        };
-        request = lib.get(url, (res) => {
-            if (res.statusCode !== 200) {
-                res.resume(); // 消费响应数据以释放内存
-                cleanupAndAbort(`下载失败，状态码: ${res.statusCode} for ${url}`);
-                return;
-            }
-            res.pipe(file);
-        });
-        file.on('finish', () => {
-            file.close((err) => {
-                if (err) {
-                    return cleanupAndAbort(`关闭临时文件流失败: ${tempFilePath}`, err);
-                }
-                fs.rename(tempFilePath, filePath, (renameErr) => {
-                    if (renameErr) {
-                        cleanupAndAbort(`缓存文件重命名失败 from ${tempFilePath} to ${filePath}`, renameErr);
-                    }
-                });
-            });
-        });
-        file.on('error', (err) => {
-            cleanupAndAbort(`写入临时文件失败: ${tempFilePath}`, err);
-        });
-        request.on('error', (err) => {
-            cleanupAndAbort(`下载资源请求失败: ${url}`, err);
-        });
-    }
-    /**
-     * 清理过期缓存文件
-     */
-    _cleanOldCache() {
-        const files = fs.readdirSync(this.options.cacheDir);
-        const now = Date.now();
-        files.forEach(file => {
-            const fullPath = path.join(this.options.cacheDir, file);
-            try {
-                const stat = fs.statSync(fullPath);
-                if (now - stat.mtimeMs > this.options.cacheTTL) {
-                    fs.unlinkSync(fullPath);
-                }
-            }
-            catch {
-                // 忽略单个文件异常
-            }
-        });
-    }
-    /**
-     * 注册 Electron 请求拦截器，实现资源缓存
-     */
-    _registerInterceptor() {
-        const shouldCache = this._getMatchFunction();
-        const isAllowedOrigin = this._getOriginAllowFunction();
-        this.session.webRequest.onBeforeRequest({ urls: ['http://*/*', 'https://*/*'] }, (details, callback) => {
-            const url = details.url;
-            // 不匹配或来源不允许，直接放行
-            if (details.method !== 'GET' || !shouldCache(url) || !isAllowedOrigin(url))
-                return callback({});
-            const cachePath = this.getCachedPath(url);
-            // 命中缓存，直接重定向到本地文件
-            if (this.isCacheValid(cachePath.filePath)) {
-                console.log('命中缓存: ', url, cachePath);
-                return callback({ redirectURL: cachePath.hostPath });
-            }
-            console.log('未命中缓存: ', url);
-            // 未命中则异步下载，当前请求正常放行
-            this.downloadResource(url, cachePath.filePath);
-            return callback({});
-        });
-    }
-}
-ResourceCache.scheme = 'cachefile';
 /**
  * @electron/remote/main enable方法
  * @param webContents
  * @returns
  */
 const enable = (webContents) => remote__namespace.enable(webContents);
-/**
- * 生成跨平台的文件URL
- * @param filePath 文件路径
- * @returns file:// URL
- */
-function getFileUrl(filePath) {
-    if (!filePath) {
-        return '';
-    }
-    if (filePath.startsWith('file://')) {
-        return filePath;
-    }
-    // 在Windows上，需要添加驱动器字母前的斜杠
-    if (process.platform === 'win32') {
-        // 如果路径是绝对路径（如 C:\path\to\file），转换为 /C:/path/to/file
-        if (filePath.match(/^[A-Za-z]:/)) {
-            return `file:///${filePath}`;
-        }
-        // 如果已经是 /C:/path/to/file 格式，直接添加 file://
-        return `file://${filePath}`;
-    }
-    // macOS 和 Linux 使用 file:/// 前缀
-    return `file://${filePath}`;
-}
 /**
  * 获取随机UUID
  * @param key
@@ -544,469 +324,6 @@ function getRandomUUID(key = `${Date.now()}`) {
     const uuid$1 = uuid.v5(`${JSON.stringify(key)}_${Date.now()}_${randomValue}`, uuid.v5.URL);
     return uuid$1;
 }
-/**
- * 视频下载和转码类
- */
-class VideoDownloader {
-    constructor() {
-        this.ffmpegPath = '';
-        this.defaultCacheTTL = 24 * 60 * 60 * 1000; // 24小时缓存有效期
-    }
-    static getInstance() {
-        if (!VideoDownloader.instance) {
-            VideoDownloader.instance = new VideoDownloader();
-        }
-        return VideoDownloader.instance;
-    }
-    setFFmpegPath(ffmpegPath) {
-        this.ffmpegPath = ffmpegPath;
-    }
-    /**
-     * 下载视频文件
-     */
-    async downloadVideoFile(url, outputPath, onProgress) {
-        return new Promise((resolve, reject) => {
-            const lib = url.startsWith('https') ? https : http;
-            const file = fs.createWriteStream(outputPath);
-            let downloadedBytes = 0;
-            let totalBytes = 0;
-            let startTime = Date.now();
-            let lastTime = startTime;
-            let lastBytes = 0;
-            const cleanup = () => {
-                if (file) {
-                    file.close();
-                    fs.unlinkSync(outputPath);
-                }
-            };
-            const request = lib.get(url, (res) => {
-                if (res.statusCode !== 200) {
-                    cleanup();
-                    reject(new Error(`下载失败，状态码: ${res.statusCode}`));
-                    return;
-                }
-                totalBytes = parseInt(res.headers['content-length'] || '0', 10);
-                res.on('data', (chunk) => {
-                    downloadedBytes += chunk.length;
-                    const now = Date.now();
-                    if (onProgress && (now - lastTime > 100 || downloadedBytes === totalBytes)) {
-                        const speed = ((downloadedBytes - lastBytes) * 1000) / (now - lastTime);
-                        onProgress({
-                            downloaded: downloadedBytes,
-                            total: totalBytes,
-                            percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
-                            speed: speed || 0
-                        });
-                        lastTime = now;
-                        lastBytes = downloadedBytes;
-                    }
-                });
-                res.pipe(file);
-                file.on('finish', () => {
-                    file.close();
-                    resolve();
-                });
-                file.on('error', (err) => {
-                    cleanup();
-                    reject(err);
-                });
-            });
-            request.on('error', (err) => {
-                cleanup();
-                reject(err);
-            });
-        });
-    }
-    /**
-     * 使用FFmpeg转码视频
-     */
-    async transcodeVideo(inputPath, outputPath, options, onProgress) {
-        return new Promise((resolve, reject) => {
-            const ffmpegPath = options.ffmpegPath || this.ffmpegPath;
-            if (!ffmpegPath) {
-                reject(new Error('FFmpeg路径未设置'));
-                return;
-            }
-            const format = options.format || 'mp4';
-            const quality = options.quality || 18;
-            const videoCodec = options.videoCodec || 'h264';
-            const audioCodec = options.audioCodec || 'aac';
-            // 根据格式选择合适的编码器
-            const getCodecForFormat = (format, videoCodec, audioCodec) => {
-                switch (format) {
-                    case 'webm':
-                        return {
-                            videoCodec: videoCodec === 'h264' ? 'libvpx-vp9' : videoCodec,
-                            audioCodec: audioCodec === 'aac' ? 'libopus' : audioCodec
-                        };
-                    case 'avi':
-                        return {
-                            videoCodec: videoCodec === 'h265' ? 'h264' : videoCodec, // AVI不支持H265
-                            audioCodec: audioCodec === 'opus' ? 'mp3' : audioCodec
-                        };
-                    case 'mov':
-                        return {
-                            videoCodec: videoCodec === 'vp9' ? 'h264' : videoCodec, // MOV对VP9支持有限
-                            audioCodec: audioCodec === 'opus' ? 'aac' : audioCodec
-                        };
-                    default: // mp4, mkv
-                        return { videoCodec, audioCodec };
-                }
-            };
-            const { videoCodec: finalVideoCodec, audioCodec: finalAudioCodec } = getCodecForFormat(format, videoCodec, audioCodec);
-            // 构建FFmpeg命令
-            const args = [
-                '-i', inputPath,
-                '-c:v', finalVideoCodec,
-                '-c:a', finalAudioCodec,
-                '-crf', quality.toString(),
-                '-preset', 'medium',
-                '-f', format, // 指定输出格式
-                '-y', // 覆盖输出文件
-                outputPath
-            ];
-            const ffmpegProcess = node_child_process.spawn(ffmpegPath, args);
-            let duration = 0;
-            let stderr = '';
-            ffmpegProcess.stderr.on('data', (data) => {
-                stderr += data.toString();
-                // 解析FFmpeg输出获取进度
-                if (onProgress) {
-                    const durationMatch = stderr.match(/Duration: (\d{2}):(\d{2}):(\d{2})\.(\d{2})/);
-                    if (durationMatch && duration === 0) {
-                        const hours = parseInt(durationMatch[1] || '0', 10);
-                        const minutes = parseInt(durationMatch[2] || '0', 10);
-                        const seconds = parseInt(durationMatch[3] || '0', 10);
-                        const centiseconds = parseInt(durationMatch[4] || '0', 10);
-                        duration = hours * 3600 + minutes * 60 + seconds + centiseconds / 100;
-                    }
-                    const timeMatch = stderr.match(/time=(\d{2}):(\d{2}):(\d{2})\.(\d{2})/);
-                    if (timeMatch && duration > 0) {
-                        const hours = parseInt(timeMatch[1] || '0', 10);
-                        const minutes = parseInt(timeMatch[2] || '0', 10);
-                        const seconds = parseInt(timeMatch[3] || '0', 10);
-                        const centiseconds = parseInt(timeMatch[4] || '0', 10);
-                        const currentTime = hours * 3600 + minutes * 60 + seconds + centiseconds / 100;
-                        const percentage = (currentTime / duration) * 100;
-                        const speedMatch = stderr.match(/speed=([\d.]+)x/);
-                        const speed = speedMatch ? parseFloat(speedMatch[1] || '1') : 1;
-                        onProgress({
-                            percentage: Math.min(percentage, 100),
-                            time: currentTime,
-                            speed: speed
-                        });
-                    }
-                }
-            });
-            ffmpegProcess.on('close', (code) => {
-                if (code === 0) {
-                    resolve();
-                }
-                else {
-                    reject(new Error(`FFmpeg转码失败，退出码: ${code}\n${stderr}`));
-                }
-            });
-            ffmpegProcess.on('error', (err) => {
-                reject(new Error(`FFmpeg执行失败: ${err.message}`));
-            });
-        });
-    }
-    /**
-     * 检查FFmpeg是否可用
-     */
-    async checkFFmpegAvailable(ffmpegPath) {
-        return new Promise((resolve) => {
-            const command = ffmpegPath || this.ffmpegPath;
-            if (!command) {
-                resolve(false);
-                return;
-            }
-            const childProcess = node_child_process.spawn(command, ['-version']);
-            childProcess.on('error', (error) => {
-                console.log("checkFFmpegAvailable", error);
-                resolve(false);
-            });
-            childProcess.on('close', (code) => {
-                console.log("checkFFmpegAvailable", code);
-                resolve(code === 0);
-            });
-        });
-    }
-    /**
-     * 获取视频信息
-     */
-    async getVideoInfo(inputPath, ffmpegPath) {
-        return new Promise((resolve, reject) => {
-            const ffmpegPath_cmd = ffmpegPath || this.ffmpegPath;
-            const args = ['-i', inputPath, '-f', 'null', '-'];
-            if (!ffmpegPath_cmd) {
-                resolve({ duration: 0, fileSize: 0 });
-                return;
-            }
-            const ffmpegProcess = node_child_process.spawn(ffmpegPath_cmd, args);
-            let stderr = '';
-            let duration = 0;
-            ffmpegProcess.stderr.on('data', (data) => {
-                stderr += data.toString();
-                const durationMatch = stderr.match(/Duration: (\d{2}):(\d{2}):(\d{2})\.(\d{2})/);
-                if (durationMatch) {
-                    const hours = parseInt(durationMatch[1] || '0', 10);
-                    const minutes = parseInt(durationMatch[2] || '0', 10);
-                    const seconds = parseInt(durationMatch[3] || '0', 10);
-                    const centiseconds = parseInt(durationMatch[4] || '0', 10);
-                    duration = hours * 3600 + minutes * 60 + seconds + centiseconds / 100;
-                }
-            });
-            ffmpegProcess.on('close', () => {
-                const stats = fs.statSync(inputPath);
-                resolve({
-                    duration,
-                    fileSize: stats.size
-                });
-            });
-            ffmpegProcess.on('error', (err) => {
-                reject(err);
-            });
-        });
-    }
-    /**
-     * 生成缓存文件名（基于URL的MD5）
-     */
-    generateCacheFileName(options) {
-        const format = options.format || 'mp4';
-        const urlMd5 = md5(options.url);
-        return `${urlMd5}.${format}`;
-    }
-    /**
-     * 检查缓存文件是否存在
-     */
-    isCacheFileExists(cacheFilePath) {
-        console.log('检查缓存文件是否存在: ', cacheFilePath);
-        return fs.existsSync(cacheFilePath);
-    }
-    /**
-     * 清理过期缓存文件
-     */
-    cleanExpiredCacheFiles(outputDir, cacheTTL = this.defaultCacheTTL) {
-        try {
-            const files = fs.readdirSync(outputDir);
-            const now = Date.now();
-            files.forEach(file => {
-                const filePath = path.join(outputDir, file);
-                try {
-                    const stats = fs.statSync(filePath);
-                    // 如果文件超过缓存时间，删除它
-                    if (now - stats.mtimeMs > cacheTTL) {
-                        fs.unlinkSync(filePath);
-                        console.log(`🧹 删除过期缓存文件: ${file}`);
-                    }
-                }
-                catch (error) {
-                    // 忽略单个文件错误
-                }
-            });
-        }
-        catch (error) {
-            // 忽略目录读取错误
-        }
-    }
-    /**
-     * 下载并转码视频
-     */
-    async downloadAndTranscode(options, callbacks) {
-        try {
-            const outputDir = options.outputDir || electron.app.getPath('temp');
-            // 获取缓存配置
-            const cacheConfig = options.cache || { enabled: true, ttl: this.defaultCacheTTL };
-            const cacheEnabled = cacheConfig.enabled !== false;
-            const cacheTTL = cacheConfig.ttl || this.defaultCacheTTL;
-            // 确保输出目录存在
-            if (!fs.existsSync(outputDir)) {
-                fs.mkdirSync(outputDir, { recursive: true });
-            }
-            // 清理过期缓存文件
-            this.cleanExpiredCacheFiles(outputDir, cacheTTL);
-            // 生成缓存文件名
-            const cacheFileName = this.generateCacheFileName(options);
-            const cacheFilePath = path.join(outputDir, cacheFileName);
-            // 如果启用缓存，检查缓存文件是否存在
-            if (cacheEnabled && this.isCacheFileExists(cacheFilePath)) {
-                console.log('🎯 命中缓存，直接返回缓存文件');
-                // 获取文件信息
-                const stats = fs.statSync(cacheFilePath);
-                const result = {
-                    success: true,
-                    outputPath: getFileUrl(cacheFilePath),
-                    fileSize: stats.size,
-                    fromCache: true
-                };
-                callbacks?.onComplete?.({
-                    success: true,
-                    outputPath: result.outputPath
-                });
-                return result;
-            }
-            // 检查FFmpeg是否可用
-            const ffmpegAvailable = await this.checkFFmpegAvailable(options.ffmpegPath);
-            if (!ffmpegAvailable) {
-                throw new Error('FFmpeg不可用，请确保已安装FFmpeg或提供正确的路径');
-            }
-            // 生成临时文件名和最终输出路径
-            const fileName = options.outputName || md5(options.url);
-            const format = options.format || 'mp4';
-            const tempPath = path.join(outputDir, `${fileName}.temp`);
-            const finalOutputPath = path.join(outputDir, `${fileName}.${format}`);
-            const outputPath = cacheEnabled ? cacheFilePath : finalOutputPath;
-            console.log('📥 开始下载视频...');
-            // 下载视频
-            await this.downloadVideoFile(options.url, tempPath, callbacks?.onDownloadProgress);
-            console.log('🔄 开始转码视频...');
-            // 转码视频
-            await this.transcodeVideo(tempPath, outputPath, {
-                ...options,
-                outputDir
-            }, callbacks?.onTranscodeProgress);
-            // 如果启用了缓存，将缓存文件复制到最终输出路径
-            if (cacheEnabled && outputPath !== finalOutputPath) {
-                fs.copyFileSync(outputPath, finalOutputPath);
-                console.log('📋 缓存文件已复制到最终输出路径');
-            }
-            // 获取视频信息
-            const videoInfo = await this.getVideoInfo(outputPath, options.ffmpegPath);
-            // 清理临时文件
-            if (!options.keepOriginal) {
-                fs.unlinkSync(tempPath);
-            }
-            console.log('💾 文件已保存到缓存');
-            const result = {
-                success: true,
-                outputPath: getFileUrl(cacheEnabled ? finalOutputPath : outputPath),
-                originalPath: options.keepOriginal ? getFileUrl(tempPath) : undefined,
-                duration: videoInfo.duration,
-                fileSize: videoInfo.fileSize,
-                fromCache: false
-            };
-            callbacks?.onComplete?.({
-                success: true,
-                outputPath: result.outputPath
-            });
-            return result;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : '未知错误';
-            const result = {
-                success: false,
-                error: errorMessage
-            };
-            callbacks?.onComplete?.({
-                success: false,
-                error: errorMessage
-            });
-            return result;
-        }
-    }
-    /**
-     * 清除指定目录的所有缓存文件
-     */
-    clearCache(outputDir) {
-        try {
-            const files = fs.readdirSync(outputDir);
-            files.forEach(file => {
-                const filePath = path.join(outputDir, file);
-                try {
-                    fs.unlinkSync(filePath);
-                }
-                catch (error) {
-                    // 忽略单个文件删除错误
-                }
-            });
-            console.log('🧹 缓存文件已清空');
-        }
-        catch (error) {
-            console.log('⚠️ 清理缓存时发生错误:', error instanceof Error ? error.message : '未知错误');
-        }
-    }
-    /**
-     * 获取缓存统计信息
-     */
-    getCacheStats(outputDir) {
-        try {
-            const files = fs.readdirSync(outputDir);
-            const entries = files.map(file => {
-                const filePath = path.join(outputDir, file);
-                try {
-                    const stats = fs.statSync(filePath);
-                    return {
-                        fileName: file,
-                        filePath: filePath,
-                        fileSize: stats.size,
-                        mtime: stats.mtimeMs
-                    };
-                }
-                catch {
-                    return null;
-                }
-            }).filter((entry) => entry !== null);
-            return {
-                size: entries.length,
-                entries
-            };
-        }
-        catch (error) {
-            return { size: 0, entries: [] };
-        }
-    }
-    /**
-     * 删除指定URL的缓存文件
-     */
-    removeCache(options) {
-        try {
-            const cacheFileName = this.generateCacheFileName(options);
-            const cacheFilePath = path.join(options.outputDir, cacheFileName);
-            if (fs.existsSync(cacheFilePath)) {
-                fs.unlinkSync(cacheFilePath);
-                console.log(`🗑️ 删除缓存文件: ${cacheFileName}`);
-                return true;
-            }
-            return false;
-        }
-        catch (error) {
-            console.log('⚠️ 删除缓存文件时发生错误:', error instanceof Error ? error.message : '未知错误');
-            return false;
-        }
-    }
-}
-/**
- * 下载视频并转码
- * @param options 下载和转码选项
- * @param callbacks 进度回调
- * @returns 转码结果
- */
-const downloadVideo = async (options, callbacks) => {
-    const downloader = VideoDownloader.getInstance();
-    return downloader.downloadAndTranscode(options, callbacks);
-};
-/**
- * 清除指定目录的所有缓存文件
- */
-const clearVideoCache = (outputDir) => {
-    const downloader = VideoDownloader.getInstance();
-    downloader.clearCache(outputDir);
-};
-/**
- * 获取缓存统计信息
- */
-const getVideoCacheStats = (outputDir) => {
-    const downloader = VideoDownloader.getInstance();
-    return downloader.getCacheStats(outputDir);
-};
-/**
- * 删除指定URL的缓存文件
- */
-const removeVideoCache = (options) => {
-    const downloader = VideoDownloader.getInstance();
-    return downloader.removeCache(options);
-};
 /**
  * 获取定制Session
  */
@@ -1032,18 +349,13 @@ const index = new Proxy({}, {
     }
 });
 
-exports.ResourceCache = ResourceCache;
-exports.clearVideoCache = clearVideoCache;
+exports.ResourceCache = resourceCache.ResourceCache;
 exports.default = index;
-exports.downloadVideo = downloadVideo;
 exports.enable = enable;
 exports.getCustomSession = getCustomSession;
-exports.getFileUrl = getFileUrl;
 exports.getRandomUUID = getRandomUUID;
 exports.getSDK = getSDK;
-exports.getVideoCacheStats = getVideoCacheStats;
 exports.initialize = initialize;
 exports.registerProtocol = registerProtocol;
-exports.removeVideoCache = removeVideoCache;
 exports.serve = serve;
 //# sourceMappingURL=index.js.map