@lobehub/chat 1.84.24 → 1.84.26

package/packages/electron-server-ipc/src/ipcServer.test.ts

@@ -0,0 +1,417 @@
+import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { ElectronIPCServer } from './ipcServer';
+
+// Mock node modules
+vi.mock('node:fs');
+vi.mock('node:net');
+vi.mock('node:os');
+vi.mock('node:path');
+
+const appId = 'lobehub';
+
+describe('ElectronIPCServer', () => {
+  // Mock data
+  const mockTempDir = '/mock/temp/dir';
+  const mockSocketPath = '/mock/temp/dir/lobehub-electron-ipc.sock';
+  const mockSocketInfoPath = '/mock/temp/dir/lobehub-electron-ipc-info.json';
+
+  // Mock server and socket
+  const mockServer = {
+    on: vi.fn(),
+    listen: vi.fn(),
+    close: vi.fn(),
+  };
+
+  const mockSocket = {
+    on: vi.fn(),
+    write: vi.fn(),
+  };
+
+  // Mock event handler
+  const mockEventHandler = {
+    testMethod: vi.fn(),
+    getStaticFilePath: vi.fn(),
+  };
+
+  beforeEach(() => {
+    // Reset all mocks
+    vi.resetAllMocks();
+
+    // 使用模拟定时器
+    vi.useFakeTimers();
+
+    // Setup common mocks
+    vi.mocked(os.tmpdir).mockReturnValue(mockTempDir);
+    vi.mocked(path.join).mockImplementation((...args) => args.join('/'));
+    vi.mocked(net.createServer).mockReturnValue(mockServer as unknown as net.Server);
+
+    // Mock socket path for different platforms
+    const originalPlatform = process.platform;
+    Object.defineProperty(process, 'platform', { value: 'darwin' });
+
+    // Mock fs functions
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    vi.mocked(fs.unlinkSync).mockReturnValue(undefined);
+    vi.mocked(fs.writeFileSync).mockReturnValue(undefined);
+
+    // Mock console methods
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  describe('server initialization and start', () => {
+    it('should create server and start listening', async () => {
+      // Setup
+      mockServer.listen.mockImplementation((path, callback) => {
+        callback?.();
+        return mockServer;
+      });
+
+      // Execute
+      const server = new ElectronIPCServer(appId, mockEventHandler as any);
+      await server.start();
+
+      // Verify
+      expect(net.createServer).toHaveBeenCalled();
+      expect(mockServer.listen).toHaveBeenCalledWith(mockSocketPath, expect.any(Function));
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        mockSocketInfoPath,
+        JSON.stringify({ socketPath: mockSocketPath }),
+        'utf8',
+      );
+    });
+
+    it('should remove existing socket file if it exists', async () => {
+      // Setup
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      mockServer.listen.mockImplementation((path, callback) => {
+        callback?.();
+        return mockServer;
+      });
+
+      // Execute
+      const server = new ElectronIPCServer(appId, mockEventHandler as any);
+
+      // Verify
+      expect(fs.existsSync).toHaveBeenCalledWith(mockSocketPath);
+      expect(fs.unlinkSync).toHaveBeenCalledWith(mockSocketPath);
+    });
+
+    it('should handle server start error', async () => {
+      // Setup
+      const mockError = new Error('Server start error');
+      mockServer.on.mockImplementation((event, callback) => {
+        if (event === 'error') {
+          callback(mockError);
+        }
+        return mockServer;
+      });
+
+      // Execute and verify
+      const server = new ElectronIPCServer(appId, mockEventHandler as any);
+      await expect(server.start()).rejects.toThrow('Server start error');
+    });
+  });
+
+  describe('connection and message handling', () => {
+    let server: ElectronIPCServer;
+    let connectionHandler: Function;
+
+    beforeEach(() => {
+      // Setup connection handler capture
+      mockServer.on.mockReset();
+      mockSocket.on.mockReset();
+      mockSocket.write.mockReset();
+
+      vi.mocked(net.createServer).mockImplementation((handler) => {
+        connectionHandler = handler as any;
+        return mockServer as unknown as net.Server;
+      });
+
+      mockServer.listen.mockImplementation((path, callback) => {
+        callback?.();
+        return mockServer;
+      });
+
+      // Create server
+      server = new ElectronIPCServer(appId, mockEventHandler as any);
+    });
+
+    it('should handle client connection and setup data listeners', async () => {
+      // Start server
+      await server.start();
+
+      // Simulate connection
+      connectionHandler(mockSocket);
+
+      // Verify socket listeners setup
+      expect(mockSocket.on).toHaveBeenCalledWith('data', expect.any(Function));
+      expect(mockSocket.on).toHaveBeenCalledWith('error', expect.any(Function));
+      expect(mockSocket.on).toHaveBeenCalledWith('close', expect.any(Function));
+    });
+
+    it('should parse messages with \n separator and execute handler', async () => {
+      // Setup mock handler
+      mockEventHandler.testMethod.mockResolvedValue('success');
+
+      // Start server
+      await server.start();
+
+      // Simulate connection
+      connectionHandler(mockSocket);
+
+      // Get data handler
+      const dataHandlerCall = mockSocket.on.mock.calls.find((call) => call[0] === 'data');
+      expect(dataHandlerCall).toBeDefined();
+      const dataHandler = dataHandlerCall![1];
+
+      // Create test message
+      const message =
+        JSON.stringify({
+          id: 'test-id',
+          method: 'testMethod',
+          params: { key: 'value' },
+        }) + '\n';
+
+      // Send message
+      await dataHandler(Buffer.from(message));
+
+      // 确保异步处理完成
+      await vi.runAllTimersAsync();
+
+      // Verify handler execution
+      expect(mockEventHandler.testMethod).toHaveBeenCalledWith(
+        { key: 'value' },
+        expect.objectContaining({
+          id: 'test-id',
+          method: 'testMethod',
+          socket: mockSocket,
+        }),
+      );
+
+      // 触发服务器端处理程序执行
+      const pendingHandlerPromise = mockEventHandler.testMethod.mock.results[0].value;
+      await pendingHandlerPromise;
+
+      // Verify response format with \n\n separator
+      expect(mockSocket.write).toHaveBeenCalledWith(
+        JSON.stringify({ id: 'test-id', result: 'success' }) + '\n\n',
+      );
+    });
+
+    it('should handle multiple messages in single data chunk', async () => {
+      // Setup mock handlers with resolved values
+      mockEventHandler.testMethod.mockResolvedValue('success1');
+      mockEventHandler.getStaticFilePath.mockResolvedValue('path/to/file');
+
+      // Start server
+      await server.start();
+
+      // Simulate connection
+      connectionHandler(mockSocket);
+
+      // Get data handler
+      const dataHandlerCall = mockSocket.on.mock.calls.find((call) => call[0] === 'data');
+      expect(dataHandlerCall).toBeDefined();
+      const dataHandler = dataHandlerCall![1];
+
+      // Create multiple messages in one chunk
+      const message1 =
+        JSON.stringify({
+          id: 'id1',
+          method: 'testMethod',
+          params: { key1: 'value1' },
+        }) + '\n\n';
+
+      const message2 =
+        JSON.stringify({
+          id: 'id2',
+          method: 'getStaticFilePath',
+          params: 'path/param',
+        }) + '\n\n';
+
+      // Send combined message
+      await dataHandler(Buffer.from(message1 + message2));
+
+      // 确保异步处理完成
+      await vi.runAllTimersAsync();
+
+      // Verify both handlers were executed
+      expect(mockEventHandler.testMethod).toHaveBeenCalledWith(
+        { key1: 'value1' },
+        expect.objectContaining({ id: 'id1', method: 'testMethod' }),
+      );
+
+      expect(mockEventHandler.getStaticFilePath).toHaveBeenCalledWith(
+        'path/param',
+        expect.objectContaining({ id: 'id2', method: 'getStaticFilePath' }),
+      );
+
+      // 等待处理程序完成
+      const promise1 = mockEventHandler.testMethod.mock.results[0].value;
+      const promise2 = mockEventHandler.getStaticFilePath.mock.results[0].value;
+      await Promise.all([promise1, promise2]);
+
+      // Verify responses
+      expect(mockSocket.write).toHaveBeenCalledTimes(2);
+      expect(mockSocket.write).toHaveBeenCalledWith(
+        JSON.stringify({ id: 'id1', result: 'success1' }) + '\n\n',
+      );
+      expect(mockSocket.write).toHaveBeenCalledWith(
+        JSON.stringify({ id: 'id2', result: 'path/to/file' }) + '\n\n',
+      );
+    });
+
+    it('should handle partial messages and buffer them', async () => {
+      // Setup mock handler
+      mockEventHandler.testMethod.mockResolvedValue('success');
+
+      // Start server
+      await server.start();
+
+      // Simulate connection
+      connectionHandler(mockSocket);
+
+      // Get data handler
+      const dataHandlerCall = mockSocket.on.mock.calls.find((call) => call[0] === 'data');
+      expect(dataHandlerCall).toBeDefined();
+      const dataHandler = dataHandlerCall![1];
+
+      // Create partial message (first half)
+      const fullMessage =
+        JSON.stringify({
+          id: 'test-id',
+          method: 'testMethod',
+          params: { data: 'test' },
+        }) + '\n\n';
+
+      const firstHalf = fullMessage.substring(0, 20);
+      await dataHandler(Buffer.from(firstHalf));
+
+      // 确保异步处理完成
+      await vi.runAllTimersAsync();
+
+      // Verify no handler calls yet
+      expect(mockEventHandler.testMethod).not.toHaveBeenCalled();
+
+      // Send second half
+      const secondHalf = fullMessage.substring(20);
+      await dataHandler(Buffer.from(secondHalf));
+
+      // 确保异步处理完成
+      await vi.runAllTimersAsync();
+
+      // Now handler should be called
+      expect(mockEventHandler.testMethod).toHaveBeenCalledWith(
+        { data: 'test' },
+        expect.objectContaining({ id: 'test-id' }),
+      );
+
+      // 等待处理程序完成
+      const pendingHandlerPromise = mockEventHandler.testMethod.mock.results[0].value;
+      await pendingHandlerPromise;
+
+      // 验证响应发送
+      expect(mockSocket.write).toHaveBeenCalledWith(
+        JSON.stringify({ id: 'test-id', result: 'success' }) + '\n\n',
+      );
+    });
+
+    it('should handle errors from method handlers', async () => {
+      // Setup mock handler to throw error
+      const mockError = new Error('Handler error');
+      mockEventHandler.testMethod.mockRejectedValue(mockError);
+
+      // Start server
+      await server.start();
+
+      // Simulate connection
+      connectionHandler(mockSocket);
+
+      // Get data handler
+      const dataHandlerCall = mockSocket.on.mock.calls.find((call) => call[0] === 'data');
+      expect(dataHandlerCall).toBeDefined();
+      const dataHandler = dataHandlerCall![1];
+
+      // Create test message
+      const message =
+        JSON.stringify({
+          id: 'test-id',
+          method: 'testMethod',
+          params: {},
+        }) + '\n\n';
+
+      // Send message
+      await dataHandler(Buffer.from(message));
+
+      // 确保异步处理完成
+      await vi.runAllTimersAsync();
+
+      // 等待Promise被拒绝
+      try {
+        const pendingHandlerPromise = mockEventHandler.testMethod.mock.results[0].value;
+        await pendingHandlerPromise;
+      } catch (error) {
+        // 错误预期会被捕获
+      }
+
+      // Verify error response
+      expect(mockSocket.write).toHaveBeenCalledWith(
+        expect.stringContaining(
+          '{"error":"Failed to handle method(testMethod): Handler error","id":"test-id"}\n\n',
+        ),
+      );
+    });
+  });
+
+  describe('server close', () => {
+    it('should close server and clean up socket file', async () => {
+      // Setup
+      mockServer.listen.mockImplementation((path, callback) => {
+        callback?.();
+        return mockServer;
+      });
+
+      // 明确模拟关闭回调
+      mockServer.close.mockImplementation((callback) => {
+        if (callback) {
+          setTimeout(() => callback(), 0);
+        }
+        return mockServer;
+      });
+
+      // 为非Windows环境设置平台
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+
+      // 模拟文件存在
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+
+      // Execute
+      const server = new ElectronIPCServer(appId, mockEventHandler as any);
+      await server.start();
+
+      // 调用关闭方法
+      const closePromise = server.close();
+
+      // 运行所有计时器使关闭回调触发
+      await vi.runAllTimersAsync();
+
+      // 等待关闭完成
+      await closePromise;
+
+      // Verify
+      expect(mockServer.close).toHaveBeenCalled();
+      expect(fs.unlinkSync).toHaveBeenCalledWith(mockSocketPath);
+    });
+  });
+});

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

@@ -70,20 +70,25 @@ export class ElectronIPCServer {
       log('Received data chunk, size: %d bytes', chunk.length);
       dataBuffer += chunk;
 
-      try {
-        // 尝试解析 JSON 消息
-        const message = JSON.parse(dataBuffer);
-        log('Successfully parsed JSON message: %o', {
-          id: message.id,
-          method: message.method,
-        });
-        dataBuffer = ''; // 重置缓冲区
-
-        // 处理请求
-        this.handleRequest(socket, message);
-      } catch {
-        // 如果不是有效的 JSON，可能是消息不完整，继续等待
-        log('Incomplete or invalid JSON, buffering for more data');
+      // 按 \n\n 分割消息
+      const messages = dataBuffer.split('\n');
+      // 保留最后一个可能不完整的消息
+      dataBuffer = messages.pop() || '';
+
+      // 处理每个完整的消息
+      for (const message of messages) {
+        if (!message.trim()) continue;
+
+        try {
+          const parsedMessage = JSON.parse(message);
+          log('Successfully parsed JSON message: %o', {
+            id: parsedMessage.id,
+            method: parsedMessage.method,
+          });
+          this.handleRequest(socket, parsedMessage);
+        } catch (err) {
+          console.error('Failed to parse message: %s', err);
+        }
       }
     });
 
@@ -123,14 +128,14 @@ export class ElectronIPCServer {
 
   // 发送结果
   private sendResult(socket: net.Socket, id: string, result: any): void {
-    const response = JSON.stringify({ id, result }) + '\n';
+    const response = JSON.stringify({ id, result }) + '\n\n';
     log('Sending success response for ID: %s, size: %d bytes', id, response.length);
     socket.write(response);
   }
 
   // 发送错误
   private sendError(socket: net.Socket, id: string, error: string): void {
-    const response = JSON.stringify({ error, id }) + '\n';
+    const response = JSON.stringify({ error, id }) + '\n\n';
     log('Sending error response for ID: %s: %s', id, error);
     socket.write(response);
   }

package/src/config/aiModels/ollama.ts

@@ -89,11 +89,22 @@ const ollamaChatModels: AIChatModelCard[] = [
     description:
       'QwQ 是 Qwen 系列的推理模型。与传统的指令调优模型相比，QwQ 具备思考和推理的能力，能够在下游任务中，尤其是困难问题上，显著提升性能。QwQ-32B 是中型推理模型，能够在与最先进的推理模型（如 DeepSeek-R1、o1-mini）竞争时取得可观的表现。',
     displayName: 'QwQ 32B',
-    enabled: true,
     id: 'qwq',
     releasedAt: '2024-11-28',
     type: 'chat',
   },
+  {
+    abilities: {
+      functionCall: true,
+    },
+    contextWindowTokens: 65_536,
+    description: 'Qwen3 是阿里巴巴的新一代大规模语言模型，以优异的性能支持多元化的应用需求。',
+    displayName: 'Qwen3 7B',
+    enabled: true,
+    id: 'qwen3',
+    type: 'chat',
+  },
+
   {
     contextWindowTokens: 128_000,
     description: 'Qwen2.5 是阿里巴巴的新一代大规模语言模型，以优异的性能支持多元化的应用需求。',
@@ -115,7 +126,6 @@ const ollamaChatModels: AIChatModelCard[] = [
     contextWindowTokens: 128_000,
     description: 'Qwen2.5 是阿里巴巴的新一代大规模语言模型，以优异的性能支持多元化的应用需求。',
     displayName: 'Qwen2.5 7B',
-    enabled: true,
     id: 'qwen2.5',
     type: 'chat',
   },

package/src/libs/langchain/loaders/epub/index.ts

@@ -2,13 +2,15 @@ import { EPubLoader as Loader } from '@langchain/community/document_loaders/fs/e
 import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
 
 import { TempFileManager } from '@/server/utils/tempFileManager';
+import { nanoid } from '@/utils/uuid';
 
 import { loaderConfig } from '../config';
 
 export const EPubLoader = async (content: Uint8Array) => {
-  const tempManager = new TempFileManager();
+  const tempManager = new TempFileManager('epub-');
+
   try {
-    const tempPath = await tempManager.writeTempFile(content);
+    const tempPath = await tempManager.writeTempFile(content, `${nanoid()}.epub`);
     const loader = new Loader(tempPath);
     const documents = await loader.load();
 

package/src/libs/mcp/__tests__/__snapshots__/index.test.ts.snap

@@ -21,9 +21,11 @@ exports[`MCPClient > Stdio Transport > should list tools via stdio 1`] = `
     "name": "echo",
   },
   {
-    "annotations": {},
     "description": "Lists all available tools and methods",
     "inputSchema": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "additionalProperties": false,
+      "properties": {},
       "type": "object",
     },
     "name": "debug",

package/src/server/routers/async/file.ts

@@ -35,7 +35,7 @@ const fileProcedure = asyncAuthedProcedure.use(async (opts) => {
       chunkService: new ChunkService(ctx.userId),
       embeddingModel: new EmbeddingModel(ctx.serverDB, ctx.userId),
       fileModel: new FileModel(ctx.serverDB, ctx.userId),
-      fileService: new FileService(),
+      fileService: new FileService(ctx.serverDB, ctx.userId),
     },
   });
 });

package/src/server/routers/lambda/file.ts

@@ -19,7 +19,7 @@ const fileProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
       asyncTaskModel: new AsyncTaskModel(ctx.serverDB, ctx.userId),
       chunkModel: new ChunkModel(ctx.serverDB, ctx.userId),
       fileModel: new FileModel(ctx.serverDB, ctx.userId),
-      fileService: new FileService(),
+      fileService: new FileService(ctx.serverDB, ctx.userId),
     },
   });
 });

package/src/server/routers/lambda/importer.ts

@@ -10,10 +10,12 @@ import { ImportResultData, ImporterEntryData } from '@/types/importer';
 
 const importProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
   const { ctx } = opts;
-  const dataImporterService = new DataImporterRepos(ctx.serverDB, ctx.userId);
 
   return opts.next({
-    ctx: { dataImporterService, fileService: new FileService() },
+    ctx: {
+      dataImporterService: new DataImporterRepos(ctx.serverDB, ctx.userId),
+      fileService: new FileService(ctx.serverDB, ctx.userId),
+    },
   });
 });
 

package/src/server/routers/lambda/message.ts

@@ -16,7 +16,7 @@ const messageProcedure = authedProcedure.use(serverDatabase).use(async (opts) =>
 
   return opts.next({
     ctx: {
-      fileService: new FileService(),
+      fileService: new FileService(ctx.serverDB, ctx.userId),
       messageModel: new MessageModel(ctx.serverDB, ctx.userId),
     },
   });
@@ -102,7 +102,7 @@ export const messageRouter = router({
       const serverDB = await getServerDB();
 
       const messageModel = new MessageModel(serverDB, ctx.userId);
-      const fileService = new FileService();
+      const fileService = new FileService(serverDB, ctx.userId);
 
       return messageModel.query(input, {
         postProcessUrl: (path) => fileService.getFullFileUrl(path),

package/src/server/routers/lambda/ragEval.ts

@@ -40,7 +40,7 @@ const ragEvalProcedure = authedProcedure
         datasetRecordModel: new EvalDatasetRecordModel(ctx.userId),
         evaluationModel: new EvalEvaluationModel(ctx.userId),
         evaluationRecordModel: new EvaluationRecordModel(ctx.userId),
-        fileService: new FileService(),
+        fileService: new FileService(ctx.serverDB, ctx.userId),
       },
     });
   });

package/src/server/routers/lambda/user.ts

@@ -1,6 +1,6 @@
 import { UserJSON } from '@clerk/backend';
+import { v4 as uuidv4 } from 'uuid';
 import { z } from 'zod';
-import { v4 as uuidv4 } from 'uuid'; // 需要添加此导入
 
 import { enableClerk } from '@/const/auth';
 import { isDesktop } from '@/const/version';
@@ -28,7 +28,7 @@ const userProcedure = authedProcedure.use(serverDatabase).use(async ({ ctx, next
   return next({
     ctx: {
       clerkAuth: new ClerkAuth(),
-      fileService: new FileService(),
+      fileService: new FileService(ctx.serverDB, ctx.userId),
       nextAuthDbAdapter: LobeNextAuthDbAdapter(ctx.serverDB),
       userModel: new UserModel(ctx.serverDB, ctx.userId),
     },

package/src/server/services/file/index.ts

@@ -1,3 +1,12 @@
+import { TRPCError } from '@trpc/server';
+
+import { serverDBEnv } from '@/config/db';
+import { FileModel } from '@/database/models/file';
+import { FileItem } from '@/database/schemas';
+import { LobeChatDatabase } from '@/database/type';
+import { TempFileManager } from '@/server/utils/tempFileManager';
+import { nanoid } from '@/utils/uuid';
+
 import { FileServiceImpl, createFileServiceModule } from './impls';
 
 /**
@@ -5,8 +14,16 @@ import { FileServiceImpl, createFileServiceModule } from './impls';
  * 使用模块化实现方式，提供文件操作服务
  */
 export class FileService {
+  private userId: string;
+  private fileModel: FileModel;
+
   private impl: FileServiceImpl = createFileServiceModule();
 
+  constructor(db: LobeChatDatabase, userId: string) {
+    this.userId = userId;
+    this.fileModel = new FileModel(db, userId);
+  }
+
   /**
    * 删除文件
    */
@@ -62,4 +79,33 @@ export class FileService {
   public async getFullFileUrl(url?: string | null, expiresIn?: number): Promise<string> {
     return this.impl.getFullFileUrl(url, expiresIn);
   }
+
+  async downloadFileToLocal(
+    fileId: string,
+  ): Promise<{ cleanup: () => void; file: FileItem; filePath: string }> {
+    const file = await this.fileModel.findById(fileId);
+    if (!file) {
+      throw new TRPCError({ code: 'BAD_REQUEST', message: 'File not found' });
+    }
+
+    let content: Uint8Array | undefined;
+    try {
+      content = await this.getFileByteArray(file.url);
+    } catch (e) {
+      console.error(e);
+      // if file not found, delete it from db
+      if ((e as any).Code === 'NoSuchKey') {
+        await this.fileModel.delete(fileId, serverDBEnv.REMOVE_GLOBAL_FILE);
+        throw new TRPCError({ code: 'BAD_REQUEST', message: 'File not found' });
+      }
+    }
+
+    if (!content) throw new TRPCError({ code: 'BAD_REQUEST', message: 'File content is empty' });
+
+    const dir = nanoid();
+    const tempManager = new TempFileManager(dir);
+
+    const filePath = await tempManager.writeTempFile(content, file.name);
+    return { cleanup: () => tempManager.cleanup(), file, filePath };
+  }
 }