@lynker-desktop/electron-sdk 0.0.9-alpha.87 → 0.0.9-alpha.89

package/main/downloader.js

@@ -48,6 +48,12 @@ class Downloader {
         this._downloadingUrls = new Map();
         /** 上一次选择的保存文件夹路径 */
         this._lastSelectedDir = null;
+        /** 缓存的下载目录路径 */
+        this._cachedDownloadsPath = null;
+        /** 目录可访问性缓存（避免重复检查） */
+        this._directoryAccessCache = new Map();
+        /** 目录缓存有效期（毫秒） */
+        this._cacheTTL = 60000; // 60秒
         electron.ipcMain.handle(`core:downloader`, async (event, options) => {
             try {
                 const { id, url } = options;
@@ -109,27 +115,93 @@ class Downloader {
         }
         // 合并进度回调：优先使用传入的 onProgress，其次使用 options.onProgress
         const progressCallback = onProgress || options.onProgress;
+        // 检查是否是 macOS App Store 环境（process.mas）
+        // 在 MAS 环境下，强制显示保存对话框，且不使用临时文件
+        const isMas = process.mas === true;
+        if (isMas) {
+            options.showSaveDialog = true;
+        }
         // 先检查是否是 base64 data URL（用于确定默认扩展名和特殊处理）
         const base64Info = this._isBase64DataUrl(url);
         const defaultExt = base64Info.isBase64 && base64Info.ext ? base64Info.ext : undefined;
         // 确定输出路径：支持弹窗选择或自动解析
         let outputPath;
+        let downloadDir;
+        let downloadFileName;
         try {
             if (options.showSaveDialog) {
                 // 显示保存对话框，让用户选择保存位置
-                const savePath = await this._showSaveDialog(url, options, defaultExt);
+                // 在 MAS 环境下，传递 isMas 标志以跳过权限检查
+                const savePath = await this._showSaveDialog(url, options, defaultExt, isMas);
                 if (!savePath) {
                     return this._createErrorResult('用户取消了保存操作', 'USER_CANCEL');
                 }
                 outputPath = savePath;
+                // 在 MAS 环境下，直接使用用户选择的路径，跳过多余的验证
+                if (isMas) {
+                    // 直接提取目录和文件名，不进行额外的验证和清理
+                    // 信任系统返回的有效路径，避免权限问题
+                    downloadDir = path.dirname(outputPath);
+                    downloadFileName = path.basename(outputPath);
+                }
+                else {
+                    // 非 MAS 环境，进行正常的路径验证和处理
+                    // 提取下载目录和文件名
+                    downloadDir = path.dirname(outputPath);
+                    downloadFileName = path.basename(outputPath);
+                    // 清理文件名，确保不包含 query 参数和特殊字符
+                    downloadFileName = this._cleanFileName(downloadFileName);
+                    // 更新 outputPath 使用清理后的文件名
+                    outputPath = path.join(downloadDir, downloadFileName);
+                }
             }
             else {
                 // 自动解析输出路径
                 outputPath = this._resolveOutputPath(url, options, defaultExt);
-            }
-            // 验证 outputPath 是否有效
-            if (!outputPath || typeof outputPath !== 'string' || outputPath.trim().length === 0) {
-                return this._createErrorResult('无法确定输出路径：路径解析结果无效', 'VALIDATION');
+                // 验证 outputPath 是否有效
+                if (!outputPath || typeof outputPath !== 'string' || outputPath.trim().length === 0) {
+                    return this._createErrorResult('无法确定输出路径：路径解析结果无效', 'VALIDATION');
+                }
+                // 准备输出路径：确保目录存在、检查文件是否已存在
+                try {
+                    const pathCheckResult = await this._prepareOutputPath(outputPath, options);
+                    if (pathCheckResult) {
+                        // 文件已存在且不允许覆盖，直接返回已存在的文件信息
+                        return pathCheckResult;
+                    }
+                }
+                catch (error) {
+                    // 路径准备失败：可能是权限问题或文件系统错误
+                    const parsedError = this._parseError(error, url);
+                    return this._createErrorResult(`准备输出路径失败: ${parsedError.message}`, parsedError.type);
+                }
+                // 提取下载目录和文件名
+                downloadDir = path.dirname(outputPath);
+                downloadFileName = path.basename(outputPath);
+                // 再次清理文件名，确保不包含 query 参数和特殊字符（防止文件系统错误）
+                downloadFileName = this._cleanFileName(downloadFileName);
+                // 验证下载目录是否可访问，如果不可用则使用系统下载目录作为备用
+                if (!this._isDirectoryAccessible(downloadDir)) {
+                    try {
+                        downloadDir = this._getDownloadsPath();
+                        // 确保备用目录存在（如果不存在则创建）
+                        if (!fs.existsSync(downloadDir)) {
+                            fs.mkdirSync(downloadDir, { recursive: true });
+                            // 创建后清除缓存，强制重新检查
+                            this._directoryAccessCache.delete(downloadDir);
+                        }
+                        // 验证备用目录是否可访问
+                        if (!this._isDirectoryAccessible(downloadDir)) {
+                            return this._createErrorResult(`无法访问下载目录: ${downloadDir}，请检查目录权限`, 'PERMISSION');
+                        }
+                    }
+                    catch (error) {
+                        const parsedError = this._parseError(error, url);
+                        return this._createErrorResult(`无法创建或访问备用下载目录: ${parsedError.message}`, parsedError.type);
+                    }
+                }
+                // 更新 outputPath 使用清理后的文件名和验证后的目录
+                outputPath = path.join(downloadDir, downloadFileName);
             }
         }
         catch (error) {
@@ -137,55 +209,24 @@ class Downloader {
             const parsedError = this._parseError(error, url);
             return this._createErrorResult(`确定输出路径失败: ${parsedError.message}`, parsedError.type);
         }
-        // 准备输出路径：确保目录存在、检查文件是否已存在
-        try {
-            const pathCheckResult = await this._prepareOutputPath(outputPath, options);
-            if (pathCheckResult) {
-                // 文件已存在且不允许覆盖，直接返回已存在的文件信息
-                return pathCheckResult;
-            }
-        }
-        catch (error) {
-            // 路径准备失败：可能是权限问题或文件系统错误
-            const parsedError = this._parseError(error, url);
-            return this._createErrorResult(`准备输出路径失败: ${parsedError.message}`, parsedError.type);
-        }
-        // 提取下载目录和文件名
-        let downloadDir = path.dirname(outputPath);
-        let downloadFileName = path.basename(outputPath);
-        // 再次清理文件名，确保不包含 query 参数和特殊字符（防止文件系统错误）
-        downloadFileName = this._cleanFileName(downloadFileName);
-        // 验证下载目录是否可访问，如果不可用则使用系统下载目录作为备用
-        if (!this._isDirectoryAccessible(downloadDir)) {
-            try {
-                downloadDir = electron.app.getPath('downloads');
-                // 确保备用目录存在（如果不存在则创建）
-                if (!fs.existsSync(downloadDir)) {
-                    fs.mkdirSync(downloadDir, { recursive: true });
-                }
-                // 验证备用目录是否可访问
-                if (!this._isDirectoryAccessible(downloadDir)) {
-                    return this._createErrorResult(`无法访问下载目录: ${downloadDir}，请检查目录权限`, 'PERMISSION');
-                }
-            }
-            catch (error) {
-                const parsedError = this._parseError(error, url);
-                return this._createErrorResult(`无法创建或访问备用下载目录: ${parsedError.message}`, parsedError.type);
-            }
-        }
-        // 更新 outputPath 使用清理后的文件名和验证后的目录
-        outputPath = path.join(downloadDir, downloadFileName);
         // 如果是 base64 data URL，使用已确定的输出路径进行特殊处理（无需网络请求）
         if (base64Info.isBase64 && base64Info.ext && base64Info.mimeType && base64Info.data) {
             return await this._handleBase64Download(url, { ext: base64Info.ext, mimeType: base64Info.mimeType, data: base64Info.data }, outputPath, options, progressCallback);
         }
         // 使用临时文件下载（.cache 后缀），避免下载中断时文件不完整
         // 下载完成后会将临时文件重命名为最终文件
-        const tempFilePath = path.join(downloadDir, downloadFileName + '.cache');
+        // 注意：在 macOS App Store 环境下（process.mas === true），不使用临时文件，直接下载到最终路径
+        const useTempFile = !isMas;
+        const tempFilePath = useTempFile
+            ? path.join(downloadDir, downloadFileName + '.cache')
+            : outputPath;
+        const actualFileName = useTempFile
+            ? downloadFileName + '.cache'
+            : downloadFileName;
         return new Promise((resolve, reject) => {
             // 创建下载器实例（使用 node-downloader-helper）
             const dl = new nodeDownloaderHelper.DownloaderHelper(url, downloadDir, {
-                fileName: downloadFileName + '.cache',
+                fileName: actualFileName,
                 retry: {
                     maxRetries: options.retry?.maxRetries ?? DEFAULT_RETRY.maxRetries,
                     delay: options.retry?.delay ?? DEFAULT_RETRY.delay
@@ -195,39 +236,175 @@ class Downloader {
                 httpRequestOptions: {
                     followRedirect: options.httpRequestOptions?.followRedirect ?? true,
                     maxRedirects: options.httpRequestOptions?.maxRedirects ?? MAX_REDIRECTS,
-                    headers: options.httpRequestOptions?.headers
+                    headers: options.httpRequestOptions?.headers,
+                    // 设置 socket 超时时间（30秒），用于更快检测网络中断
+                    // 如果 socket 在 30 秒内没有数据传输，会触发超时
+                    timeout: 30000
                 }
             });
             // 记录正在下载的 URL（使用 URL + ID 作为 key），用于避免重复下载
             this._downloadingUrls.set(downloadKey, dl);
-            // 监听下载进度事件
-            if (progressCallback) {
-                dl.on('progress', (stats) => {
+            // 进度停滞检测：用于检测网络中断
+            let lastProgressTime = Date.now();
+            let lastDownloaded = 0;
+            let progressStallTimer = null;
+            const PROGRESS_STALL_TIMEOUT = 60000; // 60秒没有进度更新则认为网络中断
+            // 进度回调节流：避免频繁触发回调（每100ms最多触发一次）
+            let lastProgressCallbackTime = 0;
+            const PROGRESS_THROTTLE_MS = 100;
+            let pendingProgress = null;
+            let progressThrottleTimer = null;
+            // 统一的错误处理函数（需要在 resetStallTimer 之前定义）
+            const handleError = (error, isUserCancel = false) => {
+                // 清理所有定时器
+                if (progressStallTimer) {
+                    clearTimeout(progressStallTimer);
+                    progressStallTimer = null;
+                }
+                if (progressThrottleTimer) {
+                    clearTimeout(progressThrottleTimer);
+                    progressThrottleTimer = null;
+                }
+                // 执行最后一次进度回调（如果有待发送的数据）
+                if (pendingProgress) {
+                    flushProgressCallback();
+                }
+                // 从下载列表中移除
+                this._downloadingUrls.delete(downloadKey);
+                // 清理临时文件（忽略删除失败，避免影响错误处理）
+                // 注意：在 macOS App Store 环境下不使用临时文件，无需清理
+                if (useTempFile) {
+                    fs.promises.unlink(tempFilePath).catch(() => {
+                        // 临时文件删除失败不影响错误处理流程
+                    });
+                }
+                // 解析错误信息
+                const parsedError = this._parseError(error, url);
+                const errorType = isUserCancel ? 'USER_CANCEL' : parsedError.type;
+                const errorMessage = isUserCancel
+                    ? `下载已取消: ${url}`
+                    : parsedError.message;
+                // 创建错误对象（包含错误类型信息）
+                const errorObj = new Error(errorMessage);
+                // 将错误类型附加到错误对象上，供 catch 处理时使用
+                errorObj.errorType = errorType;
+                // 调用错误回调
+                if (options.onError) {
+                    options.onError(errorObj);
+                }
+                // reject 应该传入 Error 对象，而不是 DownloadResult
+                reject(errorObj);
+            };
+            // 清理进度停滞检测定时器
+            const clearStallTimer = () => {
+                if (progressStallTimer) {
+                    clearTimeout(progressStallTimer);
+                    progressStallTimer = null;
+                }
+            };
+            // 重置进度停滞检测定时器
+            const resetStallTimer = () => {
+                clearStallTimer();
+                progressStallTimer = setTimeout(() => {
+                    const now = Date.now();
+                    const timeSinceLastProgress = now - lastProgressTime;
+                    // 如果超过停滞时间阈值，认为网络已中断
+                    if (timeSinceLastProgress >= PROGRESS_STALL_TIMEOUT) {
+                        const error = new Error(`网络连接中断：下载进度在 ${Math.round(timeSinceLastProgress / 1000)} 秒内没有更新`);
+                        error.code = 'ENETWORKSTALL';
+                        handleError(error, false);
+                    }
+                }, PROGRESS_STALL_TIMEOUT);
+            };
+            // 节流进度回调执行
+            const flushProgressCallback = () => {
+                if (pendingProgress && progressCallback) {
                     try {
-                        progressCallback({
-                            url,
-                            downloaded: stats.downloaded || 0,
-                            total: stats.total || 0,
-                            percentage: stats.progress !== undefined ? Math.round(stats.progress) : -1,
-                            speed: stats.speed || 0
-                        });
+                        progressCallback(pendingProgress);
+                        pendingProgress = null;
                     }
                     catch (error) {
                         // 进度回调失败不影响下载，只记录日志
                         console.error(`[Downloader] 进度回调执行失败 (${url}):`, error);
                     }
-                });
-            }
+                }
+                progressThrottleTimer = null;
+            };
+            // 监听下载进度事件
+            dl.on('progress', (stats) => {
+                const currentDownloaded = stats.downloaded || 0;
+                const currentTime = Date.now();
+                // 如果下载量有增加，更新最后进度时间和下载量，并重置停滞检测定时器
+                if (currentDownloaded > lastDownloaded) {
+                    lastDownloaded = currentDownloaded;
+                    lastProgressTime = currentTime;
+                    // 重置停滞检测定时器（因为下载有进展）
+                    resetStallTimer();
+                }
+                // 节流进度回调：更新待发送的进度数据
+                if (progressCallback) {
+                    pendingProgress = {
+                        url,
+                        downloaded: currentDownloaded,
+                        total: stats.total || 0,
+                        percentage: stats.progress !== undefined ? Math.round(stats.progress) : -1,
+                        speed: stats.speed || 0
+                    };
+                    // 如果距离上次回调超过节流时间，立即执行
+                    const timeSinceLastCallback = currentTime - lastProgressCallbackTime;
+                    if (timeSinceLastCallback >= PROGRESS_THROTTLE_MS) {
+                        flushProgressCallback();
+                        lastProgressCallbackTime = currentTime;
+                    }
+                    else if (!progressThrottleTimer) {
+                        // 否则设置定时器延迟执行
+                        progressThrottleTimer = setTimeout(() => {
+                            flushProgressCallback();
+                            lastProgressCallbackTime = Date.now();
+                        }, PROGRESS_THROTTLE_MS - timeSinceLastCallback);
+                    }
+                }
+            });
+            // 启动进度停滞检测
+            resetStallTimer();
             // 监听下载完成事件
             dl.on('end', () => {
+                clearStallTimer();
+                // 清理进度节流定时器
+                if (progressThrottleTimer) {
+                    clearTimeout(progressThrottleTimer);
+                    progressThrottleTimer = null;
+                }
+                // 执行最后一次进度回调（确保100%进度被发送）
+                if (pendingProgress) {
+                    flushProgressCallback();
+                }
                 // 从下载列表中移除
                 this._downloadingUrls.delete(downloadKey);
-                // 将临时文件重命名为最终文件（原子操作，确保文件完整性）
-                fs.rename(tempFilePath, outputPath, (renameErr) => {
-                    if (renameErr) {
-                        // 文件重命名失败：可能是权限问题或文件被占用
-                        const parsedError = this._parseError(renameErr, url);
-                        const error = new Error(`文件重命名失败: 无法将临时文件 "${tempFilePath}" 重命名为 "${outputPath}"。${parsedError.message}`);
+                // 在 macOS App Store 环境下，不使用临时文件，直接使用最终路径
+                if (!useTempFile) {
+                    // 直接获取文件信息并返回成功结果
+                    fs.promises.stat(outputPath).then(async (stats) => {
+                        try {
+                            const result = this._createSuccessResult(outputPath, stats.size);
+                            // 调用完成回调
+                            if (options.onComplete) {
+                                options.onComplete(outputPath);
+                            }
+                            resolve(result);
+                        }
+                        catch (error) {
+                            // 获取文件信息失败
+                            const parsedError = this._parseError(error, url);
+                            const errorObj = new Error(`下载完成但无法获取文件信息: ${parsedError.message}`);
+                            // 将错误类型附加到错误对象上
+                            errorObj.errorType = parsedError.type;
+                            reject(errorObj);
+                        }
+                    }).catch((statErr) => {
+                        // 获取文件信息失败
+                        const parsedError = this._parseError(statErr, url);
+                        const error = new Error(`下载完成但无法获取文件信息: ${parsedError.message}`);
                         // 调用错误回调
                         if (options.onError) {
                             options.onError(error);
@@ -236,11 +413,14 @@ class Downloader {
                         // 将错误类型附加到错误对象上
                         error.errorType = parsedError.type;
                         reject(error);
-                    }
-                    else {
+                    });
+                }
+                else {
+                    // 将临时文件重命名为最终文件（使用异步操作，避免阻塞）
+                    fs.promises.rename(tempFilePath, outputPath).then(async () => {
                         try {
-                            // 获取文件大小并返回成功结果
-                            const stats = fs.statSync(outputPath);
+                            // 获取文件大小并返回成功结果（使用异步操作）
+                            const stats = await fs.promises.stat(outputPath);
                             const result = this._createSuccessResult(outputPath, stats.size);
                             // 调用完成回调
                             if (options.onComplete) {
@@ -256,37 +436,45 @@ class Downloader {
                             errorObj.errorType = parsedError.type;
                             reject(errorObj);
                         }
-                    }
-                });
-            });
-            // 统一的错误处理函数
-            const handleError = (error, isUserCancel = false) => {
-                // 从下载列表中移除
-                this._downloadingUrls.delete(downloadKey);
-                // 清理临时文件（忽略删除失败，避免影响错误处理）
-                fs.promises.unlink(tempFilePath).catch(() => {
-                    // 临时文件删除失败不影响错误处理流程
-                });
-                // 解析错误信息
-                const parsedError = this._parseError(error, url);
-                const errorType = isUserCancel ? 'USER_CANCEL' : parsedError.type;
-                const errorMessage = isUserCancel
-                    ? `下载已取消: ${url}`
-                    : parsedError.message;
-                // 创建错误对象（包含错误类型信息）
-                const errorObj = new Error(errorMessage);
-                // 将错误类型附加到错误对象上，供 catch 处理时使用
-                errorObj.errorType = errorType;
-                // 调用错误回调
-                if (options.onError) {
-                    options.onError(errorObj);
+                    }).catch((renameErr) => {
+                        // 文件重命名失败：可能是权限问题或文件被占用
+                        const parsedError = this._parseError(renameErr, url);
+                        const error = new Error(`文件重命名失败: 无法将临时文件 "${tempFilePath}" 重命名为 "${outputPath}"。${parsedError.message}`);
+                        // 调用错误回调
+                        if (options.onError) {
+                            options.onError(error);
+                        }
+                        // reject 应该传入 Error 对象，而不是 DownloadResult
+                        // 将错误类型附加到错误对象上
+                        error.errorType = parsedError.type;
+                        reject(error);
+                    });
                 }
-                // reject 应该传入 Error 对象，而不是 DownloadResult
-                reject(errorObj);
-            };
+            });
+            // 监听超时事件（socket 超时，通常表示网络中断）
+            dl.on('timeout', () => {
+                const error = new Error(`网络连接超时：下载在指定时间内没有数据传输`);
+                error.code = 'ETIMEDOUT';
+                handleError(error, false);
+            });
             // 监听下载错误事件（网络错误、服务器错误等）
             dl.on('error', (err) => {
-                const error = err instanceof Error ? err : new Error(`下载失败: ${url}`);
+                // 检查是否是超时错误
+                const errorStats = err;
+                let error;
+                if (errorStats && typeof errorStats === 'object') {
+                    // node-downloader-helper 的 error 事件传递的是 ErrorStats 对象
+                    error = new Error(errorStats.message || `下载失败: ${url}`);
+                    if (errorStats.status) {
+                        error.status = errorStats.status;
+                    }
+                }
+                else if (err instanceof Error) {
+                    error = err;
+                }
+                else {
+                    error = new Error(`下载失败: ${url}`);
+                }
                 handleError(error, false);
             });
             // 监听下载停止事件（用户取消或手动停止）
@@ -389,7 +577,16 @@ class Downloader {
         return this._extractFileNameFromUrl(url);
     }
     /**
-     * 检查目录是否存在且有访问权限
+     * 获取下载目录路径（带缓存）
+     */
+    _getDownloadsPath() {
+        if (this._cachedDownloadsPath === null) {
+            this._cachedDownloadsPath = electron.app.getPath('downloads');
+        }
+        return this._cachedDownloadsPath;
+    }
+    /**
+     * 检查目录是否存在且有访问权限（带缓存优化）
      *
      * 检查项：
      * 1. 路径是否有效（非空字符串）
@@ -405,24 +602,38 @@ class Downloader {
         if (!dirPath || typeof dirPath !== 'string') {
             return false;
         }
+        // 检查缓存
+        const cached = this._directoryAccessCache.get(dirPath);
+        const now = Date.now();
+        if (cached && (now - cached.timestamp) < this._cacheTTL) {
+            return cached.accessible;
+        }
+        let accessible = false;
         try {
-            // 检查目录是否存在
-            if (!fs.existsSync(dirPath)) {
-                return false;
-            }
-            // 检查是否是目录（而非文件）
+            // 优化：使用 statSync 同时检查存在性和类型，然后检查权限
+            // 这样可以减少文件系统调用次数
             const stats = fs.statSync(dirPath);
-            if (!stats.isDirectory()) {
-                return false;
+            if (stats.isDirectory()) {
+                // 检查是否有读写权限（R_OK: 读权限, W_OK: 写权限）
+                fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
+                accessible = true;
             }
-            // 检查是否有读写权限（R_OK: 读权限, W_OK: 写权限）
-            fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
-            return true;
         }
         catch {
             // 如果任何检查失败（不存在、不是目录、无权限等），返回 false
-            return false;
+            accessible = false;
+        }
+        // 更新缓存
+        this._directoryAccessCache.set(dirPath, { accessible, timestamp: now });
+        // 清理过期缓存（简单策略：当缓存超过100个条目时清理）
+        if (this._directoryAccessCache.size > 100) {
+            for (const [key, value] of this._directoryAccessCache.entries()) {
+                if ((now - value.timestamp) >= this._cacheTTL) {
+                    this._directoryAccessCache.delete(key);
+                }
+            }
         }
+        return accessible;
     }
     /**
      * 显示保存对话框
@@ -437,9 +648,10 @@ class Downloader {
      * @param url 下载 URL（用于提取默认文件名）
      * @param options 下载选项（包含 defaultPath、outputDir 等）
      * @param defaultExt 默认扩展名（可选，用于 base64 URL）
+     * @param isMas 是否是 macOS App Store 环境（可选，用于跳过权限检查）
      * @returns Promise<string | null> 用户选择的保存路径，如果取消则返回 null
      */
-    async _showSaveDialog(url, options, defaultExt) {
+    async _showSaveDialog(url, options, defaultExt, isMas = false) {
         // 获取并清理默认文件名
         let defaultFileName = this._getFileName(url, options, defaultExt);
         // 获取默认目录
@@ -452,16 +664,23 @@ class Downloader {
         }
         else {
             // 如果没有指定目录，使用上一次选择的文件夹，如果没有则使用下载目录
-            // 检查 _lastSelectedDir 是否可用，如果不可用则重置为下载目录
-            if (this._lastSelectedDir && !this._isDirectoryAccessible(this._lastSelectedDir)) {
-                const downloadsPath = electron.app.getPath('downloads');
-                // 验证下载目录是否可用，如果可用则使用，否则设为 null
-                this._lastSelectedDir = this._isDirectoryAccessible(downloadsPath) ? downloadsPath : null;
+            // 在 MAS 环境下，跳过权限检查，直接使用缓存的目录或下载目录
+            if (isMas) {
+                defaultDir = this._lastSelectedDir || this._getDownloadsPath();
+            }
+            else {
+                // 检查 _lastSelectedDir 是否可用，如果不可用则重置为下载目录
+                if (this._lastSelectedDir && !this._isDirectoryAccessible(this._lastSelectedDir)) {
+                    const downloadsPath = this._getDownloadsPath();
+                    // 验证下载目录是否可用，如果可用则使用，否则设为 null
+                    this._lastSelectedDir = this._isDirectoryAccessible(downloadsPath) ? downloadsPath : null;
+                }
+                defaultDir = this._lastSelectedDir || this._getDownloadsPath();
             }
-            defaultDir = this._lastSelectedDir || electron.app.getPath('downloads');
         }
         // 如果指定了目录，检查文件是否存在并生成唯一文件名
-        if (defaultDir) {
+        // 在 MAS 环境下，跳过文件系统访问，直接使用默认文件名
+        if (defaultDir && !isMas) {
             defaultFileName = this._generateUniqueFileName(defaultDir, defaultFileName);
         }
         // 构建默认路径
@@ -491,16 +710,23 @@ class Downloader {
             return null;
         }
         // 记录用户选择的文件夹路径，用于下次默认使用
+        // 在 MAS 环境下，直接保存用户选择的目录，不进行权限检查
         const selectedDir = path.dirname(result.filePath);
         if (selectedDir) {
-            // 验证选择的目录是否可访问，只有可访问时才保存
-            if (this._isDirectoryAccessible(selectedDir)) {
+            if (isMas) {
+                // MAS 环境下，直接保存用户选择的目录，信任系统返回的路径
                 this._lastSelectedDir = selectedDir;
             }
             else {
-                // 如果选择的目录不可访问，尝试使用下载目录
-                const downloadsPath = electron.app.getPath('downloads');
-                this._lastSelectedDir = this._isDirectoryAccessible(downloadsPath) ? downloadsPath : null;
+                // 验证选择的目录是否可访问，只有可访问时才保存
+                if (this._isDirectoryAccessible(selectedDir)) {
+                    this._lastSelectedDir = selectedDir;
+                }
+                else {
+                    // 如果选择的目录不可访问，尝试使用下载目录
+                    const downloadsPath = this._getDownloadsPath();
+                    this._lastSelectedDir = this._isDirectoryAccessible(downloadsPath) ? downloadsPath : null;
+                }
             }
         }
         return result.filePath;
@@ -546,31 +772,6 @@ class Downloader {
             return { isBase64: false };
         }
     }
-    /**
-     * 保存 base64 数据到文件
-     *
-     * 处理流程：
-     * 1. 将 base64 字符串解码为 Buffer
-     * 2. 将 Buffer 写入目标文件路径
-     *
-     * @param base64Data base64 编码的数据字符串
-     * @param filePath 目标文件路径（完整路径，包含文件名）
-     * @throws 如果解码失败或文件写入失败，抛出错误
-     */
-    async _saveBase64ToFile(base64Data, filePath) {
-        try {
-            // 解码 base64 数据为 Buffer
-            const buffer = Buffer.from(base64Data, 'base64');
-            // 使用 Promise 版本的 writeFile 写入文件
-            // Buffer 继承自 Uint8Array，可以直接使用
-            await fs.promises.writeFile(filePath, buffer);
-        }
-        catch (error) {
-            // 文件保存失败：可能是权限问题、磁盘空间不足、路径无效等
-            const errorMessage = error instanceof Error ? error.message : '未知错误';
-            throw new Error(`保存 base64 文件失败 (${filePath}): ${errorMessage}`);
-        }
-    }
     /**
      * 准备输出路径
      *
@@ -654,59 +855,72 @@ class Downloader {
         };
     }
     /**
-     * 从错误对象中提取错误类型和详细信息
+     * 从错误对象中提取错误类型和详细信息（性能优化版本）
      * @param error 错误对象
      * @param url 下载的 URL（用于上下文信息）
      * @returns 包含错误类型和详细错误信息的对象
      */
     _parseError(error, url) {
         if (error instanceof Error) {
+            // 优化：只转换一次为小写，避免重复转换
             const errorMessage = error.message.toLowerCase();
-            const errorCode = error.code?.toLowerCase() || '';
+            const errorCode = (error.code || '').toLowerCase();
+            const urlSuffix = url ? ` (URL: ${url})` : '';
+            // 优化：优先检查错误代码（更可靠且更快）
+            if (errorCode) {
+                if (errorCode === 'enetworkstall' || errorCode === 'etimedout' ||
+                    errorCode === 'econnrefused' || errorCode === 'enotfound') {
+                    return {
+                        type: 'NETWORK',
+                        message: `网络错误: ${error.message}${urlSuffix}`
+                    };
+                }
+                if (errorCode === 'eacces' || errorCode === 'eperm') {
+                    return {
+                        type: 'PERMISSION',
+                        message: `权限错误: ${error.message}${urlSuffix}`
+                    };
+                }
+                if (errorCode === 'enoent') {
+                    return {
+                        type: 'FILE_SYSTEM',
+                        message: `文件系统错误: ${error.message}${urlSuffix}`
+                    };
+                }
+            }
+            // 检查错误消息（作为后备）
             // 网络相关错误
-            if (errorMessage.includes('network') ||
-                errorMessage.includes('timeout') ||
-                errorMessage.includes('econnrefused') ||
-                errorMessage.includes('enotfound') ||
-                errorMessage.includes('etimedout') ||
-                errorCode.includes('timeout') ||
-                errorCode.includes('econnrefused') ||
-                errorCode.includes('enotfound') ||
-                errorCode.includes('etimedout')) {
+            if (errorMessage.includes('network') || errorMessage.includes('timeout') ||
+                errorMessage.includes('econnrefused') || errorMessage.includes('enotfound') ||
+                errorMessage.includes('etimedout') || errorMessage.includes('连接中断') ||
+                errorMessage.includes('连接超时')) {
                 return {
                     type: 'NETWORK',
-                    message: `网络错误: ${error.message}${url ? ` (URL: ${url})` : ''}`
+                    message: `网络错误: ${error.message}${urlSuffix}`
                 };
             }
             // 文件系统相关错误
-            if (errorMessage.includes('enoent') ||
-                errorMessage.includes('eacces') ||
-                errorMessage.includes('eperm') ||
-                errorMessage.includes('file') ||
-                errorMessage.includes('directory') ||
-                errorMessage.includes('path') ||
-                errorCode.includes('enoent') ||
-                errorCode.includes('eacces') ||
-                errorCode.includes('eperm')) {
-                if (errorMessage.includes('permission') || errorMessage.includes('eacces') || errorMessage.includes('eperm')) {
+            if (errorMessage.includes('enoent') || errorMessage.includes('eacces') ||
+                errorMessage.includes('eperm') || errorMessage.includes('file') ||
+                errorMessage.includes('directory') || errorMessage.includes('path')) {
+                if (errorMessage.includes('permission') || errorMessage.includes('eacces') ||
+                    errorMessage.includes('eperm')) {
                     return {
                         type: 'PERMISSION',
-                        message: `权限错误: ${error.message}${url ? ` (URL: ${url})` : ''}`
+                        message: `权限错误: ${error.message}${urlSuffix}`
                     };
                 }
                 return {
                     type: 'FILE_SYSTEM',
-                    message: `文件系统错误: ${error.message}${url ? ` (URL: ${url})` : ''}`
+                    message: `文件系统错误: ${error.message}${urlSuffix}`
                 };
             }
             // 验证相关错误
-            if (errorMessage.includes('invalid') ||
-                errorMessage.includes('validation') ||
-                errorMessage.includes('格式') ||
-                errorMessage.includes('无效')) {
+            if (errorMessage.includes('invalid') || errorMessage.includes('validation') ||
+                errorMessage.includes('格式') || errorMessage.includes('无效')) {
                 return {
                     type: 'VALIDATION',
-                    message: `验证错误: ${error.message}${url ? ` (URL: ${url})` : ''}`
+                    message: `验证错误: ${error.message}${urlSuffix}`
                 };
             }
             // 用户取消
@@ -719,13 +933,14 @@ class Downloader {
             // 其他错误
             return {
                 type: 'UNKNOWN',
-                message: `未知错误: ${error.message}${url ? ` (URL: ${url})` : ''}`
+                message: `未知错误: ${error.message}${urlSuffix}`
             };
         }
         // 非 Error 对象
+        const urlSuffix = url ? ` (URL: ${url})` : '';
         return {
             type: 'UNKNOWN',
-            message: `未知错误: ${String(error)}${url ? ` (URL: ${url})` : ''}`
+            message: `未知错误: ${String(error)}${urlSuffix}`
         };
     }
     /**
@@ -753,8 +968,9 @@ class Downloader {
             return this._createErrorResult(`无效的 base64 data URL: 缺少数据或扩展名 (URL: ${url.substring(0, 50)}...)`, 'VALIDATION');
         }
         try {
-            // 计算数据长度（用于进度回调）
-            const dataLength = Buffer.from(base64Info.data, 'base64').length;
+            // 优化：直接解码 base64 数据，避免重复创建 Buffer
+            const buffer = Buffer.from(base64Info.data, 'base64');
+            const dataLength = buffer.length;
             // 模拟进度回调（base64 数据通常很小，立即完成）
             if (progressCallback) {
                 progressCallback({
@@ -765,8 +981,9 @@ class Downloader {
                     speed: 0
                 });
             }
-            // 保存 base64 数据到文件
-            await this._saveBase64ToFile(base64Info.data, outputPath);
+            // 保存 base64 数据到文件（直接使用已解码的 buffer）
+            // 使用 Buffer.from 创建新的 Buffer 实例，确保类型兼容
+            await fs.promises.writeFile(outputPath, Buffer.from(buffer));
             // 获取文件大小并返回成功结果
             const stats = fs.statSync(outputPath);
             const result = this._createSuccessResult(outputPath, stats.size);
@@ -795,6 +1012,10 @@ class Downloader {
      * - 如果文件已存在，添加数字后缀：filename(1).ext, filename(2).ext, ...
      * - 最多尝试 MAX_FILENAME_COUNTER 次，防止无限循环
      *
+     * 性能优化：
+     * - 使用二分查找优化查找范围（如果文件很多）
+     * - 限制最大检查次数
+     *
      * 示例：
      * - "test.pdf" -> "test.pdf" (如果不存在)
      * - "test.pdf" -> "test(1).pdf" (如果 test.pdf 已存在)
@@ -814,14 +1035,29 @@ class Downloader {
             return fileName;
         }
         // 如果存在，尝试添加数字后缀
+        // 优化：使用线性查找，但限制最大检查次数
         let counter = 1;
-        let newFileName;
+        let newFileName = `${nameWithoutExt}(${counter})${ext}`;
         let newPath;
-        do {
+        // 快速查找：先尝试常见的数字（1-10）
+        while (counter <= 10 && counter < MAX_FILENAME_COUNTER) {
             newFileName = `${nameWithoutExt}(${counter})${ext}`;
             newPath = path.join(dir, newFileName);
+            if (!fs.existsSync(newPath)) {
+                return newFileName;
+            }
             counter++;
-        } while (fs.existsSync(newPath) && counter < MAX_FILENAME_COUNTER);
+        }
+        // 如果前10个都被占用，继续查找（但限制最大次数）
+        while (counter < MAX_FILENAME_COUNTER) {
+            newFileName = `${nameWithoutExt}(${counter})${ext}`;
+            newPath = path.join(dir, newFileName);
+            if (!fs.existsSync(newPath)) {
+                return newFileName;
+            }
+            counter++;
+        }
+        // 如果达到最大次数，返回最后一个尝试的文件名
         return newFileName;
     }
     /**
@@ -979,7 +1215,7 @@ class Downloader {
                 outputDir = path.resolve(options.outputDir);
             }
             else {
-                outputDir = electron.app.getPath('downloads');
+                outputDir = this._getDownloadsPath();
             }
             // 验证输出目录是否有效
             if (!outputDir || outputDir.trim().length === 0) {