@lobehub/chat 1.84.24 → 1.84.26

package/apps/desktop/src/main/controllers/__tests__/UpdaterCtr.test.ts

@@ -0,0 +1,82 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { App } from '@/core/App';
+
+// 模拟 logger
+vi.mock('@/utils/logger', () => ({
+  createLogger: () => ({
+    info: vi.fn(),
+  }),
+}));
+
+import UpdaterCtr from '../UpdaterCtr';
+
+// 模拟 App 及其依赖项
+const mockCheckForUpdates = vi.fn();
+const mockDownloadUpdate = vi.fn();
+const mockInstallNow = vi.fn();
+const mockInstallLater = vi.fn();
+
+const mockApp = {
+  updaterManager: {
+    checkForUpdates: mockCheckForUpdates,
+    downloadUpdate: mockDownloadUpdate,
+    installNow: mockInstallNow,
+    installLater: mockInstallLater,
+  },
+} as unknown as App;
+
+describe('UpdaterCtr', () => {
+  let updaterCtr: UpdaterCtr;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    updaterCtr = new UpdaterCtr(mockApp);
+  });
+
+  describe('checkForUpdates', () => {
+    it('should call updaterManager.checkForUpdates', async () => {
+      await updaterCtr.checkForUpdates();
+      expect(mockCheckForUpdates).toHaveBeenCalled();
+    });
+  });
+
+  describe('downloadUpdate', () => {
+    it('should call updaterManager.downloadUpdate', async () => {
+      await updaterCtr.downloadUpdate();
+      expect(mockDownloadUpdate).toHaveBeenCalled();
+    });
+  });
+
+  describe('quitAndInstallUpdate', () => {
+    it('should call updaterManager.installNow', () => {
+      updaterCtr.quitAndInstallUpdate();
+      expect(mockInstallNow).toHaveBeenCalled();
+    });
+  });
+
+  describe('installLater', () => {
+    it('should call updaterManager.installLater', () => {
+      updaterCtr.installLater();
+      expect(mockInstallLater).toHaveBeenCalled();
+    });
+  });
+
+  // 测试错误处理
+  describe('error handling', () => {
+    it('should handle errors when checking for updates', async () => {
+      const error = new Error('Network error');
+      mockCheckForUpdates.mockRejectedValueOnce(error);
+
+      // 由于控制器并未明确处理并返回错误，这里我们只验证调用发生且错误正确冒泡
+      await expect(updaterCtr.checkForUpdates()).rejects.toThrow(error);
+    });
+
+    it('should handle errors when downloading updates', async () => {
+      const error = new Error('Download failed');
+      mockDownloadUpdate.mockRejectedValueOnce(error);
+
+      await expect(updaterCtr.downloadUpdate()).rejects.toThrow(error);
+    });
+  });
+}); 

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

@@ -6,12 +6,16 @@ import { promisify } from 'node:util';
 
 import { FILE_STORAGE_DIR } from '@/const/dir';
 import { makeSureDirExist } from '@/utils/file-system';
+import { createLogger } from '@/utils/logger';
 
 import { ServiceModule } from './index';
 
 const readFilePromise = promisify(fs.readFile);
 const unlinkPromise = promisify(fs.unlink);
 
+// Create logger
+const logger = createLogger('services:FileService');
+
 interface UploadFileParams {
   content: ArrayBuffer;
   filename: string;
@@ -35,8 +39,10 @@ export default class FileService extends ServiceModule {
   constructor(app) {
     super(app);
 
-    // 初始化文件存储目录
+    // Initialize file storage directory
+    logger.info('Initializing file storage directory');
     makeSureDirExist(this.UPLOADS_DIR);
+    logger.debug(`Upload directory created: ${this.UPLOADS_DIR}`);
   }
 
   /**
@@ -48,19 +54,23 @@ export default class FileService extends ServiceModule {
     hash,
     type,
   }: UploadFileParams): Promise<{ metadata: FileMetadata; success: boolean }> {
+    logger.info(`Starting to upload file: ${filename}, hash: ${hash}`);
     try {
       // 创建时间戳目录
       const date = (Date.now() / 1000 / 60 / 60).toFixed(0);
       const dirname = join(this.UPLOADS_DIR, date);
+      logger.debug(`Creating timestamp directory: ${dirname}`);
       makeSureDirExist(dirname);
 
       // 生成文件保存路径
       const fileExt = filename.split('.').pop() || '';
       const savedFilename = `${hash}${fileExt ? `.${fileExt}` : ''}`;
       const savedPath = join(dirname, savedFilename);
+      logger.debug(`Generated file save path: ${savedPath}`);
 
       // 写入文件内容
       const buffer = Buffer.from(content);
+      logger.debug(`Writing file content, size: ${buffer.length} bytes`);
       await writeFile(savedPath, buffer);
 
       // 写入元数据文件
@@ -72,10 +82,12 @@ export default class FileService extends ServiceModule {
         size: buffer.length,
         type,
       };
+      logger.debug(`Writing metadata file: ${metaFilePath}`);
       await writeFile(metaFilePath, JSON.stringify(metadata, null, 2));
 
       // 返回与S3兼容的元数据格式
       const desktopPath = `desktop://${date}/${savedFilename}`;
+      logger.info(`File upload successful: ${desktopPath}`);
 
       return {
         metadata: {
@@ -87,7 +99,7 @@ export default class FileService extends ServiceModule {
         success: true,
       };
     } catch (error) {
-      console.error('File upload failed:', error);
+      logger.error(`File upload failed:`, error);
       throw new Error(`File upload failed: ${(error as Error).message}`);
     }
   }
@@ -96,35 +108,41 @@ export default class FileService extends ServiceModule {
    * 获取文件内容
    */
   async getFile(path: string): Promise<{ content: ArrayBuffer; mimeType: string }> {
+    logger.info(`Getting file content: ${path}`);
     try {
       // 处理desktop://路径
       if (!path.startsWith('desktop://')) {
+        logger.error(`Invalid desktop file path: ${path}`);
         throw new Error(`Invalid desktop file path: ${path}`);
       }
 
       // 标准化路径格式
       // 可能收到的格式: desktop:/12345/file.png 或 desktop://12345/file.png
       const normalizedPath = path.replace(/^desktop:\/+/, 'desktop://');
+      logger.debug(`Normalized path: ${normalizedPath}`);
 
       // 解析路径
       const relativePath = normalizedPath.replace('desktop://', '');
       const filePath = join(this.UPLOADS_DIR, relativePath);
-
-      console.log('Reading file from:', filePath);
+      logger.debug(`Reading file from path: ${filePath}`);
 
       // 读取文件内容
+      logger.debug(`Starting to read file content`);
       const content = await readFilePromise(filePath);
+      logger.debug(`File content read complete, size: ${content.length} bytes`);
 
       // 读取元数据获取MIME类型
       const metaFilePath = `${filePath}.meta`;
       let mimeType = 'application/octet-stream'; // 默认MIME类型
+      logger.debug(`Attempting to read metadata file: ${metaFilePath}`);
 
       try {
         const metaContent = await readFilePromise(metaFilePath, 'utf8');
         const metadata = JSON.parse(metaContent);
         mimeType = metadata.type || mimeType;
+        logger.debug(`Got MIME type from metadata: ${mimeType}`);
       } catch (metaError) {
-        console.warn(`Failed to read metadata file: ${metaError.message}, using default MIME type`);
+        logger.warn(`Failed to read metadata file: ${(metaError as Error).message}, using default MIME type`);
         // 如果元数据文件不存在，尝试从文件扩展名猜测MIME类型
         const ext = path.split('.').pop()?.toLowerCase();
         if (ext) {
@@ -155,15 +173,17 @@ export default class FileService extends ServiceModule {
                 break;
               }
             }
+          logger.debug(`Set MIME type based on file extension: ${mimeType}`);
         }
       }
 
+      logger.info(`File retrieval successful: ${path}`);
       return {
         content: content.buffer as ArrayBuffer,
         mimeType,
       };
     } catch (error) {
-      console.error('File retrieval failed:', error);
+      logger.error(`File retrieval failed:`, error);
       throw new Error(`File retrieval failed: ${(error as Error).message}`);
     }
   }
@@ -172,29 +192,37 @@ export default class FileService extends ServiceModule {
    * 删除文件
    */
   async deleteFile(path: string): Promise<{ success: boolean }> {
+    logger.info(`Deleting file: ${path}`);
     try {
       // 处理desktop://路径
       if (!path.startsWith('desktop://')) {
+        logger.error(`Invalid desktop file path: ${path}`);
         throw new Error(`Invalid desktop file path: ${path}`);
       }
 
       // 解析路径
       const relativePath = path.replace('desktop://', '');
       const filePath = join(this.UPLOADS_DIR, relativePath);
+      logger.debug(`File deletion path: ${filePath}`);
 
       // 删除文件及其元数据
+      logger.debug(`Starting file deletion`);
       await unlinkPromise(filePath);
+      logger.debug(`File deletion successful`);
 
       // 尝试删除元数据文件，但不强制要求存在
       try {
+        logger.debug(`Attempting to delete metadata file`);
         await unlinkPromise(`${filePath}.meta`);
+        logger.debug(`Metadata file deletion successful`);
       } catch (error) {
-        console.warn(`Failed to delete metadata file: ${(error as Error).message}`);
+        logger.warn(`Failed to delete metadata file: ${(error as Error).message}`);
       }
 
+      logger.info(`File deletion operation complete: ${path}`);
       return { success: true };
     } catch (error) {
-      console.error('File deletion failed:', error);
+      logger.error(`File deletion failed:`, error);
       throw new Error(`File deletion failed: ${(error as Error).message}`);
     }
   }
@@ -203,15 +231,18 @@ export default class FileService extends ServiceModule {
    * 批量删除文件
    */
   async deleteFiles(paths: string[]): Promise<DeleteFilesResponse> {
+    logger.info(`Batch deleting files, count: ${paths.length}`);
     const errors: { message: string; path: string }[] = [];
 
     // 并行处理所有删除请求
+    logger.debug(`Starting parallel deletion requests`);
     const results = await Promise.allSettled(
       paths.map(async (path) => {
         try {
           await this.deleteFile(path);
           return { path, success: true };
         } catch (error) {
+          logger.warn(`Failed to delete file: ${path}, error: ${(error as Error).message}`);
           return {
             error: (error as Error).message,
             path,
@@ -222,8 +253,10 @@ export default class FileService extends ServiceModule {
     );
 
     // 处理结果
+    logger.debug(`Processing batch deletion results`);
     results.forEach((result) => {
       if (result.status === 'rejected') {
+        logger.error(`Unexpected error: ${result.reason}`);
         errors.push({
           message: `Unexpected error: ${result.reason}`,
           path: 'unknown',
@@ -236,20 +269,26 @@ export default class FileService extends ServiceModule {
       }
     });
 
+    const success = errors.length === 0;
+    logger.info(`Batch deletion operation complete, success: ${success}, error count: ${errors.length}`);
     return {
-      success: errors.length === 0,
+      success,
       ...(errors.length > 0 && { errors }),
     };
   }
 
   async getFilePath(path: string): Promise<string> {
+    logger.debug(`Getting filesystem path: ${path}`);
     // 处理desktop://路径
     if (!path.startsWith('desktop://')) {
+      logger.error(`Invalid desktop file path: ${path}`);
       throw new Error(`Invalid desktop file path: ${path}`);
     }
 
     // 解析路径
     const relativePath = path.replace('desktop://', '');
-    return join(this.UPLOADS_DIR, relativePath);
+    const fullPath = join(this.UPLOADS_DIR, relativePath);
+    logger.debug(`Resolved filesystem path: ${fullPath}`);
+    return fullPath;
   }
 }

package/apps/desktop/vitest.config.ts

@@ -0,0 +1,17 @@
+import { resolve } from 'node:path';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    alias: {
+      '@': resolve(__dirname, './src/main'),
+    },
+    coverage: {
+      all: false,
+      provider: 'v8',
+      reporter: ['text', 'json', 'lcov', 'text-summary'],
+      reportsDirectory: './coverage/app',
+    },
+    environment: 'node',
+  },
+});

package/changelog/v1.json

@@ -1,4 +1,22 @@
 [
+  {
+    "children": {
+      "improvements": [
+        "Add qwen3 for ollama."
+      ]
+    },
+    "date": "2025-05-08",
+    "version": "1.84.26"
+  },
+  {
+    "children": {
+      "fixes": [
+        "Fix desktop upload image on macOS."
+      ]
+    },
+    "date": "2025-05-08",
+    "version": "1.84.25"
+  },
   {
     "children": {
       "fixes": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.84.24",
+  "version": "1.84.26",
   "description": "Lobe Chat - an open-source, high-performance chatbot framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",
@@ -121,7 +121,7 @@
   "dependencies": {
     "@ant-design/icons": "^5.6.1",
     "@ant-design/pro-components": "^2.8.7",
-    "@anthropic-ai/sdk": "^0.39.0",
+    "@anthropic-ai/sdk": "^0.40.1",
     "@auth/core": "^0.38.0",
     "@aws-sdk/client-bedrock-runtime": "^3.779.0",
     "@aws-sdk/client-s3": "^3.779.0",
@@ -199,7 +199,7 @@
     "langfuse": "^3.37.1",
     "langfuse-core": "^3.37.1",
     "lodash-es": "^4.17.21",
-    "lucide-react": "^0.503.0",
+    "lucide-react": "^0.508.0",
     "mammoth": "^1.9.0",
     "mdast-util-to-markdown": "^2.1.2",
     "modern-screenshot": "^4.6.0",

package/packages/electron-server-ipc/package.json

@@ -4,6 +4,9 @@
   "private": true,
   "main": "src/index.ts",
   "types": "src/index.ts",
+  "scripts": {
+    "test": "vitest"
+  },
   "dependencies": {
     "debug": "^4.3.4"
   },

package/packages/electron-server-ipc/src/ipcClient.ts

@@ -192,39 +192,76 @@ export class ElectronIpcClient {
 
     log('Sending request: %s %o', method, params);
     return new Promise<T>((resolve, reject) => {
-      try {
-        const id = Math.random().toString(36).slice(2, 15);
-        const request = { id, method, params };
-        log('Created request with ID: %s', id);
-
-        // 将请求添加到队列
-        this.requestQueue.set(id, { reject, resolve });
-        log('Added request to queue, current queue size: %d', this.requestQueue.size);
-
-        // 设置超时
-        const timeout = setTimeout(() => {
-          this.requestQueue.delete(id);
-          const errorMsg = `Request timed out, method: ${method}`;
+      const id = Math.random().toString(36).slice(2, 15);
+      const request = { id, method, params };
+      log('Created request with ID: %s', id);
+
+      // eslint-disable-next-line no-undef
+      let requestTimeoutId: NodeJS.Timeout;
+
+      const cleanupAndResolve = (value: T) => {
+        clearTimeout(requestTimeoutId);
+        this.requestQueue.delete(id);
+        resolve(value);
+      };
+
+      const cleanupAndReject = (error: any) => {
+        clearTimeout(requestTimeoutId);
+        this.requestQueue.delete(id);
+        // 保留超时错误的 console.error 日志
+        if (
+          error &&
+          error.message &&
+          typeof error.message === 'string' &&
+          error.message.startsWith('Request timed out')
+        ) {
           console.error('Request timed out, ID: %s, method: %s', id, method);
-          reject(new Error(errorMsg));
-        }, 5000);
+        }
+        reject(error);
+      };
+
+      this.requestQueue.set(id, { reject: cleanupAndReject, resolve: cleanupAndResolve });
+      log('Added request to queue, current queue size: %d', this.requestQueue.size);
+
+      requestTimeoutId = setTimeout(() => {
+        const pendingRequest = this.requestQueue.get(id);
+        if (pendingRequest) {
+          // 请求仍在队列中，表示超时
+          // 调用其专用的 reject处理器 (cleanupAndReject)
+          const errorMsg = `Request timed out, method: ${method}`;
+          // console.error 移至 cleanupAndReject 中处理
+          pendingRequest.reject(new Error(errorMsg));
+        }
+        // 如果 pendingRequest 不存在, 表示请求已被处理，其超时已清除
+      }, 5000);
 
+      try {
         // 发送请求
-        const requestJson = JSON.stringify(request);
+        const requestJson = JSON.stringify(request) + '\n';
         log('Writing request to socket, size: %d bytes', requestJson.length);
         this.socket!.write(requestJson, (err) => {
           if (err) {
-            clearTimeout(timeout);
-            this.requestQueue.delete(id);
+            // 写入失败，请求应被视为失败
+            // 调用其 reject 处理器 (cleanupAndReject)
+            const pending = this.requestQueue.get(id);
+            if (pending) {
+              pending.reject(err); // 这会调用 cleanupAndReject
+            } else {
+              // 理论上不应发生，因为写入失败通常很快
+              // 但为安全起见，确保原始 promise 被 reject
+              cleanupAndReject(err);
+            }
             console.error('Failed to write request to socket: %o', err);
-            reject(err);
           } else {
             log('Request successfully written to socket, ID: %s', id);
           }
         });
       } catch (err) {
-        console.error('Error sending request: %o', err);
-        reject(err);
+        console.error('Error sending request (during setup/write phase): %o', err);
+        // 发生在此处的错误意味着请求甚至没有机会进入队列或设置超时
+        // 直接调用 cleanupAndReject 以确保一致性，尽管此时 requestTimeoutId 可能未定义
+        // (clearTimeout(undefined)是安全的)
+        cleanupAndReject(err);
       }
     });
   }