@lobehub/chat 1.81.9 → 1.82.1

package/src/libs/mcp/index.ts

@@ -0,0 +1,2 @@
+export * from './client';
+export * from './types';

package/src/libs/mcp/types.ts

@@ -0,0 +1,27 @@
+interface InputSchema {
+  [k: string]: unknown;
+
+  properties?: unknown | null;
+  type: 'object';
+}
+
+export interface McpTool {
+  description: string;
+  inputSchema: InputSchema;
+  name: string;
+}
+
+interface HttpMCPClientParams {
+  name: string;
+  type: 'http';
+  url: string;
+}
+
+interface StdioMCPParams {
+  args: string[];
+  command: string;
+  name: string;
+  type: 'stdio';
+}
+
+export type MCPClientParams = HttpMCPClientParams | StdioMCPParams;

package/src/locales/default/electron.ts

@@ -17,18 +17,54 @@ const electron = {
     statusDisconnected: '未连接',
     urlRequired: '请输入服务器地址',
   },
+  sync: {
+    continue: '继续',
+    inCloud: '当前使用云端同步',
+    inLocalStorage: '当前使用本地存储',
+    isIniting: '正在初始化...',
+    lobehubCloud: {
+      description: '官方提供的云版本',
+      title: 'LobeHub Cloud',
+    },
+    local: {
+      description: '使用本地数据库，完全离线可用',
+      title: '本地数据库',
+    },
+    mode: {
+      cloudSync: '云端同步',
+      localStorage: '本地存储',
+      title: '选择你的连接模式',
+      useSelfHosted: '使用自托管实例？',
+    },
+    selfHosted: {
+      description: '自行部署的社区版本',
+      title: '自托管实例',
+    },
+  },
   updater: {
+    checkingUpdate: '检查新版本',
+    checkingUpdateDesc: '正在获取版本信息...',
+    downloadNewVersion: '下载新版本',
     downloadingUpdate: '正在下载更新',
     downloadingUpdateDesc: '更新正在下载中，请稍候...',
+    installLater: '下次启动时更新',
+    isLatestVersion: '当前已是最新版本',
+    isLatestVersionDesc: '非常棒，使用的版本 {{version}} 已是最前沿的版本。',
     later: '稍后更新',
     newVersionAvailable: '新版本可用',
     newVersionAvailableDesc: '发现新版本 {{version}}，是否立即下载？',
-    restartAndInstall: '重启并安装',
+    restartAndInstall: '安装更新并重启',
     updateError: '更新错误',
     updateReady: '更新已就绪',
-    updateReadyDesc: 'Lobe Chat {{version}} 已下载完成，重启应用后即可完成安装。',
+    updateReadyDesc: '新版本 {{version}} 已下载完成，重启应用后即可完成安装。',
     upgradeNow: '立即更新',
   },
+  waitingOAuth: {
+    cancel: '取消',
+    description: '浏览器已打开授权页面，请在浏览器中完成授权',
+    helpText: '如果浏览器没有自动打开，请点击取消后重新尝试',
+    title: '等待授权连接',
+  },
 };
 
 export default electron;

package/src/locales/default/plugin.ts

@@ -35,9 +35,9 @@ export default {
         label: '标识符',
       },
       mode: {
-        'local': '可视化配置',
-        'local-tooltip': '暂时不支持可视化配置',
-        'url': '在线链接',
+        mcp: 'MCP 插件',
+        mcpExp: '实验性',
+        url: '在线链接',
       },
       name: {
         desc: '插件标题',
@@ -45,6 +45,44 @@ export default {
         placeholder: '搜索引擎',
       },
     },
+    mcp: {
+      args: {
+        desc: '传递给 STDIO 命令的参数列表，一般在这里输入 MCP 服务器名称',
+        label: '命令参数',
+        placeholder: '例如：mcp-hello-world',
+      },
+      command: {
+        desc: '用于启动 MCP STDIO Server 的可执行文件或脚本',
+        label: '命令',
+        placeholder: '例如：npx / uv / docker 等',
+      },
+      endpoint: {
+        desc: '输入你的 MCP Streamable HTTP Server 的地址',
+        label: 'MCP Endpoint URL',
+      },
+      identifier: {
+        desc: '为你的 MCP 插件指定一个名称，需要使用英文字符',
+        invalid: '只能输入英文字符、数字 、- 和_ 这两个符号',
+        label: 'MCP 插件名称',
+        placeholder: '例如：my-mcp-plugin',
+      },
+      type: {
+        desc: '选择 MCP 插件的通信方式，网页版只支持 Streamable HTTP',
+        httpFeature1: '兼容网页版与桌面端',
+        httpFeature2: '连接远程 MCP 服务端, 无需额外安装配置',
+        httpShortDesc: '基于流式 HTTP 的通信协议',
+        label: 'MCP 插件类型',
+        stdioFeature1: '更低的通信延迟, 适合本地执行',
+        stdioFeature2: '通过系统标准输入输出通信，需在本地安装运行 MCP 服务端',
+        stdioNotAvailable: 'STDIO 模式仅在桌面版可用',
+        stdioShortDesc: '基于标准输入输出的通信协议',
+        title: 'MCP 插件类型',
+      },
+      url: {
+        desc: '输入你的 MCP Server Streamable HTTP 地址，不会以 /sse 结尾',
+        label: 'Streamable HTTP Endpoint URL',
+      },
+    },
     meta: {
       author: {
         desc: '插件的作者',

package/src/server/modules/ElectronIPCClient/index.ts

@@ -0,0 +1,36 @@
+import { ElectronIpcClient } from '@lobechat/electron-server-ipc';
+
+class LobeHubElectronIpcClient extends ElectronIpcClient {
+  // 获取数据库路径
+  getDatabasePath = async (): Promise<string> => {
+    return this.sendRequest<string>('getDatabasePath');
+  };
+
+  // 获取用户数据路径
+  getUserDataPath = async (): Promise<string> => {
+    return this.sendRequest<string>('getUserDataPath');
+  };
+
+  getDatabaseSchemaHash = async () => {
+    return this.sendRequest<string>('setDatabaseSchemaHash');
+  };
+
+  setDatabaseSchemaHash = async (hash: string | undefined) => {
+    if (!hash) return;
+
+    return this.sendRequest('setDatabaseSchemaHash', hash);
+  };
+
+  getFilePathById = async (id: string) => {
+    return this.sendRequest<string>('getStaticFilePath', id);
+  };
+
+  deleteFiles = async (paths: string[]) => {
+    return this.sendRequest<{ errors?: { message: string; path: string }[]; success: boolean }>(
+      'deleteFiles',
+      paths,
+    );
+  };
+}
+
+export const electronIpcClient = new LobeHubElectronIpcClient();

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

@@ -97,14 +97,10 @@ export const sessionRouter = router({
     }),
 
   getGroupedSessions: publicProcedure.query(async ({ ctx }): Promise<ChatSessionList> => {
-    if (!ctx.userId)
-      return {
-        sessionGroups: [],
-        sessions: [],
-      };
+    if (!ctx.userId) return { sessionGroups: [], sessions: [] };
 
     const serverDB = await getServerDB();
-    const sessionModel = new SessionModel(serverDB, ctx.userId);
+    const sessionModel = new SessionModel(serverDB, ctx.userId!);
 
     return sessionModel.queryWithGroups();
   }),

package/src/server/routers/tools/index.ts

@@ -1,9 +1,11 @@
 import { publicProcedure, router } from '@/libs/trpc/lambda';
 
+import { mcpRouter } from './mcp';
 import { searchRouter } from './search';
 
 export const toolsRouter = router({
   healthcheck: publicProcedure.query(() => "i'm live!"),
+  mcp: mcpRouter,
   search: searchRouter,
 });
 

package/src/server/routers/tools/mcp.ts

@@ -0,0 +1,85 @@
+import { TRPCError } from '@trpc/server';
+import { z } from 'zod';
+
+import { isDesktop, isServerMode } from '@/const/version';
+import { passwordProcedure } from '@/libs/trpc/edge';
+import { authedProcedure, router } from '@/libs/trpc/lambda';
+import { mcpService } from '@/server/services/mcp';
+
+// Define Zod schemas for MCP Client parameters
+const httpParamsSchema = z.object({
+  name: z.string().min(1),
+  type: z.literal('http'),
+  url: z.string().url(),
+});
+
+const stdioParamsSchema = z.object({
+  args: z.array(z.string()).optional().default([]),
+  command: z.string().min(1),
+  name: z.string().min(1),
+  type: z.literal('stdio'),
+});
+
+// Union schema for MCPClientParams
+const mcpClientParamsSchema = z.union([httpParamsSchema, stdioParamsSchema]);
+
+const checkStdioEnvironment = (params: z.infer<typeof mcpClientParamsSchema>) => {
+  if (params.type === 'stdio' && !isDesktop) {
+    throw new TRPCError({
+      code: 'BAD_REQUEST',
+      message: 'Stdio MCP type is not supported in web environment.',
+    });
+  }
+};
+
+const mcpProcedure = isServerMode ? authedProcedure : passwordProcedure;
+
+export const mcpRouter = router({
+  getStdioMcpServerManifest: mcpProcedure.input(stdioParamsSchema).query(async ({ input }) => {
+    // Stdio check can be done here or rely on the service/client layer
+    checkStdioEnvironment(input);
+
+    return await mcpService.getStdioMcpServerManifest(input.name, input.command, input.args);
+  }),
+  getStreamableMcpServerManifest: mcpProcedure
+    .input(
+      z.object({
+        identifier: z.string(),
+        url: z.string().url(),
+      }),
+    )
+    .query(async ({ input }) => {
+      return await mcpService.getStreamableMcpServerManifest(input.identifier, input.url);
+    }),
+  /* eslint-disable sort-keys-fix/sort-keys-fix */
+  // --- MCP Interaction ---
+  // listTools now accepts MCPClientParams directly
+  listTools: mcpProcedure
+    .input(mcpClientParamsSchema) // Use the unified schema
+    .query(async ({ input }) => {
+      // Stdio check can be done here or rely on the service/client layer
+      checkStdioEnvironment(input);
+
+      // Pass the validated MCPClientParams to the service
+      return await mcpService.listTools(input);
+    }),
+
+  // callTool now accepts MCPClientParams, toolName, and args
+  callTool: mcpProcedure
+    .input(
+      z.object({
+        params: mcpClientParamsSchema, // Use the unified schema for client params
+        args: z.any(), // Arguments for the tool call
+        toolName: z.string(),
+      }),
+    )
+    .mutation(async ({ input }) => {
+      // Stdio check can be done here or rely on the service/client layer
+      checkStdioEnvironment(input.params);
+
+      // Pass the validated params, toolName, and args to the service
+      const data = await mcpService.callTool(input.params, input.toolName, input.args);
+
+      return JSON.stringify(data);
+    }),
+});

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

@@ -1,11 +1,19 @@
+import { isDesktop } from '@/const/version';
+
+import { DesktopLocalFileImpl } from './local';
 import { S3StaticFileImpl } from './s3';
 import { FileServiceImpl } from './type';
 
 /**
  * 创建文件服务模块
+ * 根据环境自动选择使用S3或桌面本地文件实现
  */
 export const createFileServiceModule = (): FileServiceImpl => {
-  // 默认使用 S3 实现
+  // 如果在桌面应用环境，使用本地文件实现
+  if (isDesktop) {
+    return new DesktopLocalFileImpl();
+  }
+
   return new S3StaticFileImpl();
 };
 

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();
+    });
+  });
+});