@lobehub/lobehub 2.0.0-next.303 → 2.0.0-next.304

package/apps/desktop/src/main/modules/updater/configs.ts

@@ -1,34 +1,34 @@
 import { isDev } from '@/const/env';
 import { getDesktopEnv } from '@/env';
 
-// 更新频道（stable, beta, alpha 等）
+// Update channel (stable, beta, alpha, etc.)
 export const UPDATE_CHANNEL = getDesktopEnv().UPDATE_CHANNEL || 'stable';
 
-// 判断是否为 stable 频道
+// Determine if stable channel
 export const isStableChannel = UPDATE_CHANNEL === 'stable' || !UPDATE_CHANNEL;
 
-// 自定义更新服务器 URL (用于 stable 频道)
+// Custom update server URL (for stable channel)
 // e.g., https://releases.lobehub.com/stable
 export const UPDATE_SERVER_URL = getDesktopEnv().UPDATE_SERVER_URL;
 
-// GitHub 配置 (用于 beta/nightly 频道，或作为 fallback)
+// GitHub configuration (for beta/nightly channels, or as fallback)
 export const githubConfig = {
   owner: 'lobehub',
   repo: 'lobe-chat',
 };
 
 export const updaterConfig = {
-  // 应用更新配置
+  // 应用Update configuration
   app: {
-    // 是否自动检查更新
+    // Whether to auto-check for updates
     autoCheckUpdate: true,
-    // 是否自动下载更新
+    // Whether to auto-download updates
     autoDownloadUpdate: true,
-    // 检查更新的时间间隔（毫秒）
-    checkUpdateInterval: 60 * 60 * 1000, // 1小时
+    // Update check interval (milliseconds)
+    checkUpdateInterval: 60 * 60 * 1000, // 1 hour
   },
 
-  // 是否启用应用更新
+  // Whether to enable application updates
   enableAppUpdate: !isDev,
 
   // 是否启用渲染层热更新

package/apps/desktop/src/main/modules/updater/utils.ts

@@ -1,33 +1,33 @@
 import semver from 'semver';
 
 /**
- * 判断是否需要应用更新而非仅渲染层更新
- * @param currentVersion 当前版本
- * @param nextVersion 新版本
- * @returns 是否需要应用更新
+ * Determine if application update is needed rather than just renderer update
+ * @param currentVersion Current version
+ * @param nextVersion New version
+ * @returns Whether application update is needed
  */
 export const shouldUpdateApp = (currentVersion: string, nextVersion: string): boolean => {
-  // 如果版本号包含 .app 后缀，强制进行应用更新
+  // If version contains .app suffix, force application update
   if (nextVersion.includes('.app')) {
     return true;
   }
 
   try {
-    // 解析版本号
+    // Parse version number
     const current = semver.parse(currentVersion);
     const next = semver.parse(nextVersion);
 
     if (!current || !next) return true;
 
-    // 主版本号或次版本号变更时，需要进行应用更新
+    // Application update needed when major or minor version changes
     if (current.major !== next.major || current.minor !== next.minor) {
       return true;
     }
 
-    // 仅修订版本号变更，优先进行渲染层热更新
+    // For patch version changes only, prioritize renderer hot update
     return false;
   } catch {
-    // 解析失败时，默认进行应用更新
+    // Default to application update when parsing fails
     return true;
   }
 };

package/apps/desktop/src/main/services/fileSrv.ts

@@ -11,7 +11,7 @@ import { createLogger } from '@/utils/logger';
 import { ServiceModule } from './index';
 
 /**
- * 文件未找到错误类
+ * File not found error class
  */
 export class FileNotFoundError extends Error {
   constructor(
@@ -46,8 +46,8 @@ export interface FileMetadata {
 
 export default class FileService extends ServiceModule {
   /**
-   * 获取旧版上传目录路径
-   * @deprecated 仅用于向后兼容旧版文件访问，新文件应存储在 FILE_STORAGE_DIR 的自定义路径下
+   * Get legacy upload directory path
+   * @deprecated Only for backward compatibility with legacy file access, new files should be stored under custom paths in FILE_STORAGE_DIR
    */
   get UPLOADS_DIR() {
     return join(this.app.appStoragePath, FILE_STORAGE_DIR, 'uploads');
@@ -58,7 +58,7 @@ export default class FileService extends ServiceModule {
   }
 
   /**
-   * 上传文件到本地存储
+   * Upload file to local storage
    */
   async uploadFile({
     content,
@@ -69,15 +69,15 @@ export default class FileService extends ServiceModule {
   }: UploadFileParams): Promise<{ metadata: FileMetadata; success: boolean }> {
     logger.info(`Starting to upload file: ${filename}, hash: ${hash}, path: ${filePath}`);
     try {
-      // 获取当前时间戳，避免重复调用 Date.now()
+      // Get current timestamp, avoid repeated Date.now() calls
       const now = Date.now();
       const date = (now / 1000 / 60 / 60).toFixed(0);
 
-      // 使用传入的 filePath 作为文件的存储路径
+      // Use provided filePath as the file storage path
       const fullStoragePath = join(this.app.appStoragePath, FILE_STORAGE_DIR, filePath);
       logger.debug(`Target file storage path: ${fullStoragePath}`);
 
-      // 确保目标目录存在
+      // Ensure target directory exists
       const targetDir = path.dirname(fullStoragePath);
       logger.debug(`Ensuring target directory exists: ${targetDir}`);
       makeSureDirExist(targetDir);
@@ -85,23 +85,23 @@ export default class FileService extends ServiceModule {
       const savedPath = fullStoragePath;
       logger.debug(`Final file save path: ${savedPath}`);
 
-      // 根据 content 类型创建 Buffer
+      // Create Buffer based on content type
       let buffer: Buffer;
       if (typeof content === 'string') {
-        // 来自服务端的 Base64 字符串
+        // Base64 string from server
         buffer = Buffer.from(content, 'base64');
         logger.debug(`Creating buffer from Base64 string, size: ${buffer.length} bytes`);
       } else {
-        // 来自浏览器端的 ArrayBuffer
+        // ArrayBuffer from browser
         buffer = Buffer.from(content);
         logger.debug(`Creating buffer from ArrayBuffer, size: ${buffer.length} bytes`);
       }
       await writeFile(savedPath, buffer);
 
-      // 写入元数据文件
+      // Write metadata file
       const metaFilePath = `${savedPath}.meta`;
       const metadata = {
-        createdAt: now, // 使用统一的时间戳
+        createdAt: now, // Use unified timestamp
         filename,
         hash,
         size: buffer.length,
@@ -110,18 +110,18 @@ export default class FileService extends ServiceModule {
       logger.debug(`Writing metadata file: ${metaFilePath}`);
       await writeFile(metaFilePath, JSON.stringify(metadata, null, 2));
 
-      // 返回与S3兼容的元数据格式
+      // Return S3-compatible metadata format
       const desktopPath = `desktop://${filePath}`;
       logger.info(`File upload successful: ${desktopPath}`);
 
-      // 从路径中提取文件名和目录信息
+      // Extract filename and directory information from path
       const parsedPath = path.parse(filePath);
       const dirname = parsedPath.dir || '';
       const savedFilename = parsedPath.base;
 
       return {
         metadata: {
-          date, // 保持时间戳格式，用于兼容性和时间追踪
+          date, // Keep timestamp format for compatibility and time tracking
           dirname,
           filename: savedFilename,
           path: desktopPath,
@@ -135,25 +135,25 @@ export default class FileService extends ServiceModule {
   }
 
   /**
-   * 判断路径是否为旧版格式（时间戳目录）
+   * Check if path is in legacy format (timestamp directory)
    *
-   * 旧版路径格式: {timestamp}/{hash}.{ext} (例如: 1234567890/abc123.png)
-   * 新版路径格式: 任意自定义路径 (例如: user_uploads/images/photo.png, ai_generations/image.jpg)
+   * Legacy path format: {timestamp}/{hash}.{ext} (e.g., 1234567890/abc123.png)
+   * New path format: arbitrary custom paths (e.g., user_uploads/images/photo.png, ai_generations/image.jpg)
    *
-   * @param path - 相对路径，不包含 desktop:// 前缀
-   * @returns true 如果是旧版格式，false 如果是新版格式
+   * @param path - Relative path, without desktop:// prefix
+   * @returns true if legacy format, false if new format
    */
   private isLegacyPath(path: string): boolean {
     const parts = path.split('/');
     if (parts.length < 2) return false;
 
-    // 如果第一部分是纯数字（时间戳），则认为是旧版格式
-    // 时间戳格式：精确到小时的 Unix 时间戳，通常是 10 位数字
+    // If the first part is purely numeric (timestamp), consider it legacy format
+    // Timestamp format: Unix timestamp accurate to the hour, typically 10 digits
     return /^\d+$/.test(parts[0]);
   }
 
   /**
-   * 获取文件内容
+   * Get file content
    */
   async getFile(path: string): Promise<{ content: ArrayBuffer; mimeType: string }> {
     logger.info(`Getting file content: ${path}`);
@@ -164,30 +164,30 @@ export default class FileService extends ServiceModule {
         throw new Error(`Invalid desktop file path: ${path}`);
       }
 
-      // 标准化路径格式
-      // 可能收到的格式: desktop:/12345/file.png 或 desktop://12345/file.png
+      // Normalize path format
+      // Possible formats received: desktop:/12345/file.png or desktop://12345/file.png
       const normalizedPath = path.replace(/^desktop:\/+/, 'desktop://');
       logger.debug(`Normalized path: ${normalizedPath}`);
 
-      // 解析路径
+      // Parse path
       const relativePath = normalizedPath.replace('desktop://', '');
 
-      // 智能路由：根据路径格式决定从哪个目录读取文件
+      // Smart routing: decide which directory to read file from based on path format
       let filePath: string;
       let isLegacyAttempt = false;
 
       if (this.isLegacyPath(relativePath)) {
-        // 旧版路径：从 uploads 目录读取（向后兼容）
+        // Legacy path: read from uploads directory (backward compatibility)
         filePath = join(this.UPLOADS_DIR, relativePath);
         isLegacyAttempt = true;
         logger.debug(`Legacy path detected, reading from uploads directory: ${filePath}`);
       } else {
-        // 新版路径：从 FILE_STORAGE_DIR 根目录读取
+        // New path: read from FILE_STORAGE_DIR root directory
         filePath = join(this.app.appStoragePath, FILE_STORAGE_DIR, relativePath);
         logger.debug(`New path format, reading from storage root: ${filePath}`);
       }
 
-      // 读取文件内容，如果第一次尝试失败且是 legacy 路径，则尝试新路径
+      // Read file content, if first attempt fails and is legacy path, try new path
       logger.debug(`Starting to read file content`);
       let content: Buffer;
       try {
@@ -195,14 +195,14 @@ export default class FileService extends ServiceModule {
         logger.debug(`File content read complete, size: ${content.length} bytes`);
       } catch (firstError) {
         if (isLegacyAttempt) {
-          // 如果是 legacy 路径读取失败，尝试从新路径读取
+          // If legacy path read fails, try reading from new path
           const fallbackPath = join(this.app.appStoragePath, FILE_STORAGE_DIR, relativePath);
           logger.debug(
             `Legacy path read failed, attempting fallback to storage root: ${fallbackPath}`,
           );
           try {
             content = await readFilePromise(fallbackPath);
-            filePath = fallbackPath; // 更新 filePath 用于后续的元数据读取
+            filePath = fallbackPath; // Update filePath for subsequent metadata reading
             logger.debug(`Fallback read successful, size: ${content.length} bytes`);
           } catch (fallbackError) {
             logger.error(
@@ -215,9 +215,9 @@ export default class FileService extends ServiceModule {
         }
       }
 
-      // 读取元数据获取MIME类型
+      // Read metadata to get MIME type
       const metaFilePath = `${filePath}.meta`;
-      let mimeType = 'application/octet-stream'; // 默认MIME类型
+      let mimeType = 'application/octet-stream'; // Default MIME type
       logger.debug(`Attempting to read metadata file: ${metaFilePath}`);
 
       try {
@@ -229,7 +229,7 @@ export default class FileService extends ServiceModule {
         logger.warn(
           `Failed to read metadata file: ${(metaError as Error).message}, using default MIME type`,
         );
-        // 如果元数据文件不存在，尝试从文件扩展名猜测MIME类型
+        // If metadata file doesn't exist, try to guess MIME type from file extension
         const ext = path.split('.').pop()?.toLowerCase();
         if (ext) {
           if (['jpg', 'jpeg'].includes(ext)) mimeType = 'image/jpeg';
@@ -271,7 +271,7 @@ export default class FileService extends ServiceModule {
     } catch (error) {
       logger.error(`File retrieval failed:`, error);
 
-      // 如果是文件不存在错误，抛出自定义的 FileNotFoundError
+      // If file not found error, throw custom FileNotFoundError
       if (error instanceof Error && error.message.includes('ENOENT')) {
         throw new FileNotFoundError(`File not found: ${path}`, path);
       }
@@ -281,7 +281,7 @@ export default class FileService extends ServiceModule {
   }
 
   /**
-   * 删除文件
+   * Delete file
    */
   async deleteFile(path: string): Promise<{ success: boolean }> {
     logger.info(`Deleting file: ${path}`);
@@ -292,42 +292,42 @@ export default class FileService extends ServiceModule {
         throw new Error(`Invalid desktop file path: ${path}`);
       }
 
-      // 标准化路径格式
+      // Normalize path format
       const normalizedPath = path.replace(/^desktop:\/+/, 'desktop://');
 
-      // 解析路径
+      // Parse path
       const relativePath = normalizedPath.replace('desktop://', '');
 
-      // 智能路由：根据路径格式决定从哪个目录删除文件
+      // Smart routing: decide which directory to delete file from based on path format
       let filePath: string;
       let isLegacyAttempt = false;
 
       if (this.isLegacyPath(relativePath)) {
-        // 旧版路径：从 uploads 目录删除（向后兼容）
+        // Legacy path: delete from uploads directory (backward compatibility)
         filePath = join(this.UPLOADS_DIR, relativePath);
         isLegacyAttempt = true;
         logger.debug(`Legacy path detected, deleting from uploads directory: ${filePath}`);
       } else {
-        // 新版路径：从 FILE_STORAGE_DIR 根目录删除
+        // New path: delete from FILE_STORAGE_DIR root directory
         filePath = join(this.app.appStoragePath, FILE_STORAGE_DIR, relativePath);
         logger.debug(`New path format, deleting from storage root: ${filePath}`);
       }
 
-      // 删除文件及其元数据，如果第一次尝试失败且是 legacy 路径，则尝试新路径
+      // Delete file and its metadata, if first attempt fails and is legacy path, try new path
       logger.debug(`Starting file deletion`);
       try {
         await unlinkPromise(filePath);
         logger.debug(`File deletion successful`);
       } catch (firstError) {
         if (isLegacyAttempt) {
-          // 如果是 legacy 路径删除失败，尝试从新路径删除
+          // If legacy path deletion fails, try deleting from new path
           const fallbackPath = join(this.app.appStoragePath, FILE_STORAGE_DIR, relativePath);
           logger.debug(
             `Legacy path deletion failed, attempting fallback to storage root: ${fallbackPath}`,
           );
           try {
             await unlinkPromise(fallbackPath);
-            filePath = fallbackPath; // 更新 filePath 用于后续的元数据删除
+            filePath = fallbackPath; // Update filePath for subsequent metadata deletion
             logger.debug(`Fallback deletion successful`);
           } catch (fallbackError) {
             logger.error(
@@ -340,7 +340,7 @@ export default class FileService extends ServiceModule {
         }
       }
 
-      // 尝试删除元数据文件，但不强制要求存在
+      // Try to delete metadata file, but don't require it to exist
       try {
         logger.debug(`Attempting to delete metadata file`);
         await unlinkPromise(`${filePath}.meta`);
@@ -358,13 +358,13 @@ export default class FileService extends ServiceModule {
   }
 
   /**
-   * 批量删除文件
+   * Batch delete files
    */
   async deleteFiles(paths: string[]): Promise<DeleteFilesResponse> {
     logger.info(`Batch deleting files, count: ${paths.length}`);
     const errors: { message: string; path: string }[] = [];
 
-    // 并行处理所有删除请求
+    // Process all deletion requests in parallel
     logger.debug(`Starting parallel deletion requests`);
     const results = await Promise.allSettled(
       paths.map(async (path) => {
@@ -382,7 +382,7 @@ export default class FileService extends ServiceModule {
       }),
     );
 
-    // 处理结果
+    // Process results
     logger.debug(`Processing batch deletion results`);
     results.forEach((result) => {
       if (result.status === 'rejected') {
@@ -411,31 +411,31 @@ export default class FileService extends ServiceModule {
 
   async getFilePath(path: string): Promise<string> {
     logger.debug(`Getting filesystem path: ${path}`);
-    // 处理desktop://路径
+    // Handle desktop:// paths
     if (!path.startsWith('desktop://')) {
       logger.error(`Invalid desktop file path: ${path}`);
       throw new Error(`Invalid desktop file path: ${path}`);
     }
 
-    // 标准化路径格式
+    // Normalize path format
     const normalizedPath = path.replace(/^desktop:\/+/, 'desktop://');
 
-    // 解析路径
+    // Parse path
     const relativePath = normalizedPath.replace('desktop://', '');
 
-    // 智能路由：根据路径格式决定从哪个目录获取文件路径
+    // Smart routing: decide which directory to get file path from based on path format
     let fullPath: string;
     if (this.isLegacyPath(relativePath)) {
-      // 旧版路径：从 uploads 目录获取（向后兼容）
+      // Legacy path: get from uploads directory (backward compatibility)
       fullPath = join(this.UPLOADS_DIR, relativePath);
       logger.debug(`Legacy path detected, resolved to uploads directory: ${fullPath}`);
 
-      // 检查文件是否存在，如果不存在则尝试新路径
+      // Check if file exists, if not try new path
       try {
         await fs.promises.access(fullPath, fs.constants.F_OK);
         logger.debug(`Legacy path file exists: ${fullPath}`);
       } catch {
-        // 如果 legacy 路径文件不存在，尝试新路径
+        // If legacy path file doesn't exist, try new path
         const fallbackPath = join(this.app.appStoragePath, FILE_STORAGE_DIR, relativePath);
         logger.debug(`Legacy path file not found, trying fallback path: ${fallbackPath}`);
         try {
@@ -443,14 +443,14 @@ export default class FileService extends ServiceModule {
           fullPath = fallbackPath;
           logger.debug(`Fallback path file exists: ${fullPath}`);
         } catch {
-          // 两个路径都不存在，返回原始的 legacy 路径（保持原有行为）
+          // Neither path exists, return original legacy path (maintain existing behavior)
           logger.debug(
             `Neither legacy nor fallback path exists, returning legacy path: ${fullPath}`,
           );
         }
       }
     } else {
-      // 新版路径：从 FILE_STORAGE_DIR 根目录获取
+      // New path: get from FILE_STORAGE_DIR root directory
       fullPath = join(this.app.appStoragePath, FILE_STORAGE_DIR, relativePath);
       logger.debug(`New path format, resolved to storage root: ${fullPath}`);
     }
@@ -460,19 +460,19 @@ export default class FileService extends ServiceModule {
 
   async getFileHTTPURL(path: string): Promise<string> {
     logger.debug(`Getting file HTTP URL: ${path}`);
-    // 处理desktop://路径
+    // Handle desktop:// paths
     if (!path.startsWith('desktop://')) {
       logger.error(`Invalid desktop file path: ${path}`);
       throw new Error(`Invalid desktop file path: ${path}`);
     }
 
-    // 标准化路径格式
+    // Normalize path format
     const normalizedPath = path.replace(/^desktop:\/+/, 'desktop://');
 
-    // 解析路径：从 desktop://path/to/file.png 中提取 path/to/file.png
+    // Parse path: extract path/to/file.png from desktop://path/to/file.png
     const relativePath = normalizedPath.replace('desktop://', '');
 
-    // 使用 StaticFileServerManager 获取文件服务器域名，然后构建完整 URL
+    // Use StaticFileServerManager to get file server domain, then construct full URL
     const serverDomain = this.app.staticFileServerManager.getFileServerDomain();
     const httpURL = `${serverDomain}${LOCAL_STORAGE_URL_PREFIX}/${relativePath}`;
     logger.debug(`Generated HTTP URL: ${httpURL}`);

package/apps/desktop/src/main/shortcuts/config.ts

@@ -1,10 +1,10 @@
 /**
- * 快捷键操作类型枚举
+ * Shortcut action type enum
  */
 export const ShortcutActionEnum = {
   openSettings: 'openSettings',
   /**
-   * 显示/隐藏主窗口
+   * Show/hide main window
    */
   showApp: 'showApp',
 } as const;
@@ -12,7 +12,7 @@ export const ShortcutActionEnum = {
 export type ShortcutActionType = (typeof ShortcutActionEnum)[keyof typeof ShortcutActionEnum];
 
 /**
- * 默认快捷键配置
+ * Default shortcut configuration
  */
 export const DEFAULT_SHORTCUTS_CONFIG: Record<ShortcutActionType, string> = {
   [ShortcutActionEnum.showApp]: 'Control+E',

package/apps/desktop/src/main/types/protocol.ts

@@ -1,5 +1,5 @@
 /**
- * MCP Schema - stdio 配置类型
+ * MCP Schema - stdio configuration type
  */
 export interface McpStdioConfig {
   args?: string[];
@@ -9,7 +9,7 @@ export interface McpStdioConfig {
 }
 
 /**
- * MCP Schema - http 配置类型
+ * MCP Schema - http configuration type
  */
 export interface McpHttpConfig {
   headers?: Record<string, string>;
@@ -18,26 +18,26 @@ export interface McpHttpConfig {
 }
 
 /**
- * MCP Schema 配置类型
+ * MCP Schema configuration type
  */
 export type McpConfig = McpStdioConfig | McpHttpConfig;
 
 /**
- * MCP Schema 对象
- * 符合 RFC 0001 定义
+ * MCP Schema object
+ * Conforms to RFC 0001 definition
  */
 export interface McpSchema {
-  /** 插件作者 */
+  /** Plugin author */
   author: string;
-  /** 插件配置 */
+  /** Plugin configuration */
   config: McpConfig;
-  /** 插件描述 */
+  /** Plugin description */
   description: string;
-  /** 插件主页 */
+  /** Plugin homepage */
   homepage?: string;
-  /** 插件图标 */
+  /** Plugin icon */
   icon?: string;
-  /** 插件唯一标识符，必须与URL中的id参数匹配 */
+  /** Plugin unique identifier，必须与URL中的id参数匹配 */
   identifier: string;
   /** 插件名称 */
   name: string;
@@ -49,7 +49,7 @@ export interface McpSchema {
  * 协议URL解析结果
  */
 export interface ProtocolUrlParsed {
-  /** 操作类型 (如: 'install') */
+  /** Action type (e.g., 'install') */
   action: string;
   /** 原始URL */
   originalUrl: string;

package/apps/desktop/src/main/utils/file-system.ts

@@ -4,11 +4,11 @@ export const makeSureDirExist = (dir: string) => {
   try {
     statSync(dir);
   } catch {
-    // 使用 recursive: true，如果目录已存在则此操作无效果，如果不存在则创建
+    // Use recursive: true, no effect if directory exists, create if it doesn't
     try {
       mkdirSync(dir, { recursive: true });
     } catch (mkdirError: any) {
-      // 如果创建目录失败（例如权限问题），则抛出错误
+      // Throw error if directory creation fails (e.g., permission issues)
       throw new Error(`Could not create target directory: ${dir}. Error: ${mkdirError.message}`);
     }
   }

package/apps/desktop/src/main/utils/logger.ts

@@ -3,14 +3,14 @@ import electronLog from 'electron-log';
 
 import { getDesktopEnv } from '@/env';
 
-// 配置 electron-log
-electronLog.transports.file.level = 'info'; // 生产环境记录 info 及以上级别
+// Configure electron-log
+electronLog.transports.file.level = 'info'; // Log info level and above in production
 electronLog.transports.console.level =
   getDesktopEnv().NODE_ENV === 'development'
-    ? 'debug' // 开发环境显示更多日志
-    : 'warn'; // 生产环境只显示警告和错误
+    ? 'debug' // Show more logs in development
+    : 'warn'; // Only show warnings and errors in production
 
-// 创建命名空间调试器
+// Create namespaced debugger
 export const createLogger = (namespace: string) => {
   const debugLogger = debug(namespace);