@lobehub/chat 1.82.0 → 1.82.2

package/src/server/services/file/impls/local.test.ts

@@ -0,0 +1,299 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { electronIpcClient } from '@/server/modules/ElectronIPCClient';
+
+import { DesktopLocalFileImpl } from './local';
+
+// 模拟依赖项
+vi.mock('node:fs', async (importOriginal) => ({
+  ...((await importOriginal()) as any),
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+}));
+
+vi.mock('@/server/modules/ElectronIPCClient', () => ({
+  electronIpcClient: {
+    getFilePathById: vi.fn(),
+    deleteFiles: vi.fn(),
+  },
+}));
+
+describe('DesktopLocalFileImpl', () => {
+  let service: DesktopLocalFileImpl;
+  const testFilePath = '/path/to/file.txt';
+  const testFileKey = 'desktop://file.txt';
+  const testFileContent = 'test file content';
+  const testFileBuffer = Buffer.from(testFileContent);
+
+  beforeEach(() => {
+    service = new DesktopLocalFileImpl();
+
+    // 重置所有模拟
+    vi.resetAllMocks();
+
+    // 设置默认模拟行为
+    vi.mocked(electronIpcClient.getFilePathById).mockResolvedValue(testFilePath);
+    vi.mocked(existsSync).mockReturnValue(true);
+    vi.mocked(readFileSync).mockReturnValueOnce(testFileBuffer);
+  });
+
+  describe('getLocalFileUrl', () => {
+    it.skip('应该正确获取本地文件URL并转换为data URL', async () => {
+      // 准备: readFileSync在第一次被调用时返回文件内容
+      vi.mocked(readFileSync).mockReturnValueOnce(testFileBuffer);
+
+      // 使用私有方法进行测试，通过原型访问
+      const result = await (service as any).getLocalFileUrl(testFileKey);
+
+      // 验证
+      expect(electronIpcClient.getFilePathById).toHaveBeenCalledWith(testFileKey);
+      expect(existsSync).toHaveBeenCalledWith(testFilePath);
+      expect(readFileSync).toHaveBeenCalledWith(testFilePath);
+
+      // 验证返回的data URL格式正确
+      expect(result).toContain('data:text/plain;base64,');
+      expect(result).toContain(testFileBuffer.toString('base64'));
+    });
+
+    it('当文件不存在时应返回原始键', async () => {
+      // 准备: 文件不存在
+      vi.mocked(existsSync).mockReturnValueOnce(false);
+
+      // 使用私有方法进行测试
+      const result = await (service as any).getLocalFileUrl(testFileKey);
+
+      // 验证
+      expect(result).toBe(testFileKey);
+    });
+
+    it('当发生错误时应返回空字符串', async () => {
+      // 准备: 模拟错误
+      vi.mocked(electronIpcClient.getFilePathById).mockRejectedValueOnce(new Error('测试错误'));
+
+      // 使用私有方法进行测试
+      const result = await (service as any).getLocalFileUrl(testFileKey);
+
+      // 验证
+      expect(result).toBe('');
+    });
+  });
+
+  describe('getMimeTypeFromPath', () => {
+    it('应该返回正确的MIME类型', () => {
+      // 使用私有方法进行测试
+      const jpgResult = (service as any).getMimeTypeFromPath('test.jpg');
+      const pngResult = (service as any).getMimeTypeFromPath('test.png');
+      const unknownResult = (service as any).getMimeTypeFromPath('test.unknown');
+
+      // 验证
+      expect(jpgResult).toBe('image/jpeg');
+      expect(pngResult).toBe('image/png');
+      expect(unknownResult).toBe('application/octet-stream');
+    });
+  });
+
+  describe('createPreSignedUrl', () => {
+    it('应该返回原始键', async () => {
+      const result = await service.createPreSignedUrl(testFileKey);
+
+      expect(result).toBe(testFileKey);
+    });
+  });
+
+  describe('createPreSignedUrlForPreview', () => {
+    it('应该调用getLocalFileUrl获取预览URL', async () => {
+      // 准备
+      const getLocalFileUrlSpy = vi.spyOn(service as any, 'getLocalFileUrl');
+      getLocalFileUrlSpy.mockResolvedValueOnce('data:text/plain;base64,dGVzdA==');
+
+      // 执行
+      const result = await service.createPreSignedUrlForPreview(testFileKey);
+
+      // 验证
+      expect(getLocalFileUrlSpy).toHaveBeenCalledWith(testFileKey);
+      expect(result).toBe('data:text/plain;base64,dGVzdA==');
+    });
+  });
+
+  describe('deleteFile', () => {
+    it('应该调用deleteFiles方法删除单个文件', async () => {
+      // 准备
+      vi.mocked(electronIpcClient.deleteFiles).mockResolvedValueOnce({ success: true });
+      const deleteFilesSpy = vi.spyOn(service, 'deleteFiles');
+
+      // 执行
+      await service.deleteFile(testFileKey);
+
+      // 验证
+      expect(deleteFilesSpy).toHaveBeenCalledWith([testFileKey]);
+    });
+  });
+
+  describe('deleteFiles', () => {
+    it('应该成功删除有效的文件', async () => {
+      // 准备
+      const keys = ['desktop://file1.txt', 'desktop://file2.png'];
+      vi.mocked(electronIpcClient.deleteFiles).mockResolvedValueOnce({ success: true });
+
+      // 执行
+      const result = await service.deleteFiles(keys);
+
+      // 验证
+      expect(electronIpcClient.deleteFiles).toHaveBeenCalledWith(keys);
+      expect(result).toEqual({ success: true });
+    });
+
+    it('当提供无效键时应返回错误', async () => {
+      // 准备: 包含无效的文件路径
+      const keys = ['invalid://file1.txt', 'desktop://file2.png'];
+
+      // 执行
+      const result = await service.deleteFiles(keys);
+
+      // 验证
+      expect(electronIpcClient.deleteFiles).not.toHaveBeenCalled();
+      expect(result.success).toBe(false);
+      expect(result.errors).toBeDefined();
+      expect(result.errors!.length).toBe(1);
+      expect(result.errors![0].path).toBe('invalid://file1.txt');
+    });
+
+    it('当未提供键时应返回成功', async () => {
+      // 执行
+      const result = await service.deleteFiles([]);
+
+      // 验证
+      expect(electronIpcClient.deleteFiles).not.toHaveBeenCalled();
+      expect(result).toEqual({ success: true });
+    });
+
+    it('当删除过程中出现错误时应正确处理', async () => {
+      // 准备
+      const keys = ['desktop://file1.txt'];
+      vi.mocked(electronIpcClient.deleteFiles).mockRejectedValueOnce(new Error('删除错误'));
+
+      // 执行
+      const result = await service.deleteFiles(keys);
+
+      // 验证
+      expect(result.success).toBe(false);
+      expect(result.errors).toBeDefined();
+      expect(result.errors![0].message).toContain('删除错误');
+    });
+  });
+
+  describe.skip('getFileByteArray', () => {
+    it('应该返回文件的字节数组', async () => {
+      // 准备
+      vi.mocked(readFileSync).mockReturnValueOnce(Buffer.from('测试内容'));
+
+      // 执行
+      const result = await service.getFileByteArray(testFileKey);
+
+      // 验证
+      expect(electronIpcClient.getFilePathById).toHaveBeenCalledWith(testFileKey);
+      expect(existsSync).toHaveBeenCalledWith(testFilePath);
+      expect(readFileSync).toHaveBeenCalledWith(testFilePath);
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(Buffer.from(result).toString()).toBe('测试内容');
+    });
+
+    it('当文件不存在时应返回空数组', async () => {
+      // 准备
+      vi.mocked(existsSync).mockReturnValueOnce(false);
+
+      // 执行
+      const result = await service.getFileByteArray(testFileKey);
+
+      // 验证
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(result.length).toBe(0);
+    });
+
+    it('当发生错误时应返回空数组', async () => {
+      // 准备
+      vi.mocked(electronIpcClient.getFilePathById).mockRejectedValueOnce(new Error('测试错误'));
+
+      // 执行
+      const result = await service.getFileByteArray(testFileKey);
+
+      // 验证
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe.skip('getFileContent', () => {
+    it('应该返回文件内容', async () => {
+      // 准备
+      vi.mocked(readFileSync).mockReturnValueOnce('文件内容');
+
+      // 执行
+      const result = await service.getFileContent(testFileKey);
+
+      // 验证
+      expect(electronIpcClient.getFilePathById).toHaveBeenCalledWith(testFileKey);
+      expect(existsSync).toHaveBeenCalledWith(testFilePath);
+      expect(readFileSync).toHaveBeenCalledWith(testFilePath, 'utf8');
+      expect(result).toBe('文件内容');
+    });
+
+    it('当文件不存在时应返回空字符串', async () => {
+      // 准备
+      vi.mocked(existsSync).mockReturnValueOnce(false);
+
+      // 执行
+      const result = await service.getFileContent(testFileKey);
+
+      // 验证
+      expect(result).toBe('');
+    });
+
+    it('当发生错误时应返回空字符串', async () => {
+      // 准备
+      vi.mocked(electronIpcClient.getFilePathById).mockRejectedValueOnce(new Error('测试错误'));
+
+      // 执行
+      const result = await service.getFileContent(testFileKey);
+
+      // 验证
+      expect(result).toBe('');
+    });
+  });
+
+  describe('getFullFileUrl', () => {
+    it('应该调用getLocalFileUrl获取完整URL', async () => {
+      // 准备
+      const getLocalFileUrlSpy = vi.spyOn(service as any, 'getLocalFileUrl');
+      getLocalFileUrlSpy.mockResolvedValueOnce('data:image/png;base64,test');
+
+      // 执行
+      const result = await service.getFullFileUrl(testFileKey);
+
+      // 验证
+      expect(getLocalFileUrlSpy).toHaveBeenCalledWith(testFileKey);
+      expect(result).toBe('data:image/png;base64,test');
+    });
+
+    it('当url为空时应返回空字符串', async () => {
+      // 执行
+      const result = await service.getFullFileUrl(null);
+
+      // 验证
+      expect(result).toBe('');
+    });
+  });
+
+  describe('uploadContent', () => {
+    it('应该正确处理上传内容的请求', async () => {
+      // 目前这个方法未实现，仅验证调用不会导致错误
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      await service.uploadContent('path/to/file', 'content');
+
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+  });
+});

package/src/server/services/file/impls/local.ts

@@ -0,0 +1,183 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import { electronIpcClient } from '@/server/modules/ElectronIPCClient';
+
+import { FileServiceImpl } from './type';
+
+/**
+ * 桌面应用本地文件服务实现
+ */
+export class DesktopLocalFileImpl implements FileServiceImpl {
+  /**
+   * 获取本地文件的URL
+   * Electron返回文件的绝对路径，然后在服务端将文件转为base64
+   */
+  private async getLocalFileUrl(key: string): Promise<string> {
+    try {
+      // 从Electron获取文件的绝对路径
+      const filePath = await electronIpcClient.getFilePathById(key);
+
+      // 检查文件是否存在
+      if (!existsSync(filePath)) {
+        console.error(`File not found: ${filePath}`);
+        return key;
+      }
+
+      // 读取文件内容
+      const fileContent = readFileSync(filePath);
+
+      // 确定文件的MIME类型
+      const mimeType = this.getMimeTypeFromPath(filePath);
+
+      // 转换为base64并返回data URL
+      const base64 = fileContent.toString('base64');
+      return `data:${mimeType};base64,${base64}`;
+    } catch (e) {
+      console.error('[DesktopLocalFileImpl] Failed to process file from Electron IPC:', e);
+      return '';
+    }
+  }
+
+  /**
+   * 根据文件路径获取MIME类型
+   */
+  private getMimeTypeFromPath(filePath: string): string {
+    const extension = path.extname(filePath).toLowerCase();
+
+    // 常见文件类型的MIME映射
+    const mimeTypes: Record<string, string> = {
+      '.css': 'text/css',
+      '.gif': 'image/gif',
+      '.html': 'text/html',
+      '.jpeg': 'image/jpeg',
+      '.jpg': 'image/jpeg',
+      '.js': 'application/javascript',
+      '.json': 'application/json',
+      '.pdf': 'application/pdf',
+      '.png': 'image/png',
+      '.svg': 'image/svg+xml',
+      '.txt': 'text/plain',
+      '.webp': 'image/webp',
+    };
+
+    return mimeTypes[extension] || 'application/octet-stream';
+  }
+
+  /**
+   * 创建预签名上传URL（本地版实际上是直接返回文件路径，可能需要进一步扩展）
+   */
+  async createPreSignedUrl(key: string): Promise<string> {
+    // 在桌面应用本地文件实现中，不需要预签名URL
+    // 直接返回文件路径
+    return key;
+  }
+
+  /**
+   * 创建预签名预览URL（本地版是通过Electron获取本地文件URL）
+   */
+  async createPreSignedUrlForPreview(key: string): Promise<string> {
+    return this.getLocalFileUrl(key);
+  }
+
+  async deleteFile(key: string): Promise<any> {
+    return await this.deleteFiles([key]);
+  }
+
+  /**
+   * 批量删除文件
+   */
+  async deleteFiles(keys: string[]): Promise<any> {
+    try {
+      if (!keys || keys.length === 0) return { success: true };
+
+      // 确保所有路径都是合法的desktop://路径
+      const invalidKeys = keys.filter((key) => !key.startsWith('desktop://'));
+      if (invalidKeys.length > 0) {
+        console.error('Invalid desktop file paths:', invalidKeys);
+        return {
+          errors: invalidKeys.map((key) => ({ message: 'Invalid desktop file path', path: key })),
+          success: false,
+        };
+      }
+
+      // 使用electronIpcClient的专用方法
+      return await electronIpcClient.deleteFiles(keys);
+    } catch (error) {
+      console.error('Failed to delete files:', error);
+      return {
+        errors: [
+          {
+            message: `Batch delete failed: ${(error as Error).message}`,
+            path: 'batch',
+          },
+        ],
+        success: false,
+      };
+    }
+  }
+
+  /**
+   * 获取文件字节数组
+   */
+  async getFileByteArray(key: string): Promise<Uint8Array> {
+    try {
+      // 从Electron获取文件的绝对路径
+      const filePath = await electronIpcClient.getFilePathById(key);
+
+      // 检查文件是否存在
+      if (!existsSync(filePath)) {
+        console.error(`File not found: ${filePath}`);
+        return new Uint8Array();
+      }
+
+      // 读取文件内容并转换为Uint8Array
+      const buffer = readFileSync(filePath);
+      return new Uint8Array(buffer);
+    } catch (e) {
+      console.error('Failed to get file byte array:', e);
+      return new Uint8Array();
+    }
+  }
+
+  /**
+   * 获取文件内容
+   */
+  async getFileContent(key: string): Promise<string> {
+    try {
+      // 从Electron获取文件的绝对路径
+      const filePath = await electronIpcClient.getFilePathById(key);
+
+      // 检查文件是否存在
+      if (!existsSync(filePath)) {
+        console.error(`File not found: ${filePath}`);
+        return '';
+      }
+
+      // 读取文件内容并转换为字符串
+      return readFileSync(filePath, 'utf8');
+    } catch (e) {
+      console.error('Failed to get file content:', e);
+      return '';
+    }
+  }
+
+  /**
+   * 获取完整文件URL
+   */
+  async getFullFileUrl(url?: string | null): Promise<string> {
+    if (!url) return '';
+    return this.getLocalFileUrl(url);
+  }
+
+  /**
+   * 上传内容
+   * 注意：这个功能可能需要扩展Electron IPC接口
+   */
+  async uploadContent(filePath: string, content: string): Promise<any> {
+    // 这里需要扩展electronIpcClient以支持上传文件内容
+    // 例如: return electronIpcClient.uploadContent(filePath, content);
+    console.warn('uploadContent not implemented for Desktop local file service', filePath, content);
+    return;
+  }
+}

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

@@ -1,4 +1,5 @@
 import { LobeChatPluginApi, LobeChatPluginManifest, PluginSchema } from '@lobehub/chat-plugin-sdk';
+import { McpError } from '@modelcontextprotocol/sdk/types.js';
 import { TRPCError } from '@trpc/server';
 import debug from 'debug';
 
@@ -61,6 +62,12 @@ class MCPService {
 
       return result;
     } catch (error) {
+      if (error instanceof McpError) {
+        const mcpError = error as McpError;
+
+        return mcpError.message;
+      }
+
       console.error(`Error calling tool "${toolName}" for params %O:`, params, error);
       // Propagate a TRPCError
       throw new TRPCError({
@@ -139,6 +146,25 @@ class MCPService {
   ): Promise<LobeChatPluginManifest> {
     const tools = await this.listTools({ name: identifier, type: 'http', url }); // Get client using params
 
+    return {
+      api: tools,
+      identifier,
+      meta: {
+        avatar: 'MCP_AVATAR',
+        description: `${identifier} MCP server has ${tools.length} tools, like "${tools[0]?.name}"`,
+        title: identifier,
+      },
+      // TODO: temporary
+      type: 'mcp' as any,
+    };
+  }
+  async getStdioMcpServerManifest(
+    identifier: string,
+    command: string,
+    args: string[],
+  ): Promise<LobeChatPluginManifest> {
+    const tools = await this.listTools({ args, command, name: identifier, type: 'stdio' }); // Get client using params
+
     return {
       api: tools,
       identifier,

package/src/services/aiModel/index.ts

@@ -1,5 +1,9 @@
+import { isDesktop } from '@/const/version';
+
 import { ClientService } from './client';
 import { ServerService } from './server';
 
 export const aiModelService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : new ClientService();
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
+    ? new ServerService()
+    : new ClientService();

package/src/services/aiProvider/index.ts

@@ -1,5 +1,9 @@
+import { isDesktop } from '@/const/version';
+
 import { ClientService } from './client';
 import { ServerService } from './server';
 
 export const aiProviderService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : new ClientService();
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
+    ? new ServerService()
+    : new ClientService();

package/src/services/electron/autoUpdate.ts

@@ -12,6 +12,10 @@ class AutoUpdateService {
   installLater = async () => {
     return dispatch('installLater');
   };
+
+  downloadUpdate() {
+    return dispatch('downloadUpdate');
+  }
 }
 
 export const autoUpdateService = new AutoUpdateService();

package/src/services/file/index.ts

@@ -1,3 +1,5 @@
+import { isDesktop } from '@/const/version';
+
 import { ClientService as DeprecatedService } from './_deprecated';
 import { ClientService } from './client';
 import { ServerService } from './server';
@@ -6,4 +8,6 @@ const clientService =
   process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new DeprecatedService();
 
 export const fileService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : clientService;
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
+    ? new ServerService()
+    : clientService;

package/src/services/mcp.ts

@@ -1,12 +1,14 @@
 import { toolsClient } from '@/libs/trpc/client';
-import { getToolStoreState } from '@/store/tool';
-import { pluginSelectors } from '@/store/tool/slices/plugin/selectors';
 import { ChatToolPayload } from '@/types/message';
 
 class MCPService {
   async invokeMcpToolCall(payload: ChatToolPayload, { signal }: { signal?: AbortSignal }) {
+    const { pluginSelectors } = await import('@/store/tool/selectors');
+    const { getToolStoreState } = await import('@/store/tool/store');
+
     const s = getToolStoreState();
     const { identifier, arguments: args, apiName } = payload;
+
     const plugin = pluginSelectors.getCustomPluginById(identifier)(s);
 
     if (!plugin) return;
@@ -20,6 +22,15 @@ class MCPService {
   async getStreamableMcpServerManifest(identifier: string, url: string) {
     return toolsClient.mcp.getStreamableMcpServerManifest.query({ identifier, url });
   }
+
+  async getStdioMcpServerManifest(identifier: string, command: string, args?: string[]) {
+    return toolsClient.mcp.getStdioMcpServerManifest.query({
+      args: args,
+      command,
+      name: identifier,
+      type: 'stdio',
+    });
+  }
 }
 
 export const mcpService = new MCPService();

package/src/services/message/index.ts

@@ -1,3 +1,5 @@
+import { isDesktop } from '@/const/version';
+
 import { ClientService as DeprecatedService } from './_deprecated';
 import { ClientService } from './client';
 import { ServerService } from './server';
@@ -6,4 +8,6 @@ const clientService =
   process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new DeprecatedService();
 
 export const messageService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : clientService;
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
+    ? new ServerService()
+    : clientService;

package/src/services/plugin/index.ts

@@ -1,3 +1,5 @@
+import { isDesktop } from '@/const/version';
+
 import { ClientService as DeprecatedService } from './_deprecated';
 import { ClientService } from './client';
 import { ServerService } from './server';
@@ -6,4 +8,6 @@ const clientService =
   process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new DeprecatedService();
 
 export const pluginService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : clientService;
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
+    ? new ServerService()
+    : clientService;

package/src/services/session/index.ts

@@ -1,3 +1,5 @@
+import { isDesktop } from '@/const/version';
+
 import { ClientService as DeprecatedService } from './_deprecated';
 import { ClientService } from './client';
 import { ServerService } from './server';
@@ -6,4 +8,6 @@ const clientService =
   process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new DeprecatedService();
 
 export const sessionService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : clientService;
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
+    ? new ServerService()
+    : clientService;

package/src/services/tableViewer/desktop.ts

@@ -0,0 +1,15 @@
+import { desktopClient } from '@/libs/trpc/client/desktop';
+
+export class DesktopService {
+  getAllTables = async () => {
+    return desktopClient.pgTable.getAllTables.query();
+  };
+
+  getTableDetails = async (tableName: string) => {
+    return desktopClient.pgTable.getTableDetails.query({ tableName });
+  };
+
+  getTableData = async (tableName: string) => {
+    return desktopClient.pgTable.getTableData.query({ page: 1, pageSize: 300, tableName });
+  };
+}

package/src/services/tableViewer/index.ts

@@ -1,3 +1,6 @@
+import { isDesktop } from '@/const/version';
+
 import { ClientService } from './client';
+import { DesktopService } from './desktop';
 
-export const tableViewerService = new ClientService();
+export const tableViewerService = isDesktop ? new DesktopService() : new ClientService();

package/src/services/thread/index.ts

@@ -1,5 +1,9 @@
+import { isDesktop } from '@/const/version';
+
 import { ClientService } from './client';
 import { ServerService } from './server';
 
 export const threadService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : new ClientService();
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
+    ? new ServerService()
+    : new ClientService();