@lobehub/chat 1.81.9 → 1.82.1

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

@@ -0,0 +1,176 @@
+import { LobeChatPluginApi, LobeChatPluginManifest, PluginSchema } from '@lobehub/chat-plugin-sdk';
+import { TRPCError } from '@trpc/server';
+import debug from 'debug';
+
+import { MCPClient, MCPClientParams } from '@/libs/mcp';
+import { safeParseJSON } from '@/utils/safeParseJSON';
+
+const log = debug('lobe-mcp:service');
+
+// Removed MCPConnection interface as it's no longer needed
+
+class MCPService {
+  // Store instances of the custom MCPClient, keyed by serialized MCPClientParams
+  private clients: Map<string, MCPClient> = new Map();
+
+  constructor() {
+    log('MCPService initialized');
+  }
+
+  // --- MCP Interaction ---
+
+  // listTools now accepts MCPClientParams
+  async listTools(params: MCPClientParams): Promise<LobeChatPluginApi[]> {
+    const client = await this.getClient(params); // Get client using params
+    log(`Listing tools using client for params: %O`, params);
+
+    try {
+      const result = await client.listTools();
+      log(`Tools listed successfully for params: %O, result count: %d`, params, result.length);
+      return result.map<LobeChatPluginApi>((item) => ({
+        // Assuming identifier is the unique name/id
+        description: item.description,
+        name: item.name,
+        parameters: item.inputSchema as PluginSchema,
+      }));
+    } catch (error) {
+      console.error(`Error listing tools for params %O:`, params, error);
+      // Propagate a TRPCError for better handling upstream
+      throw new TRPCError({
+        cause: error,
+        code: 'INTERNAL_SERVER_ERROR',
+        message: `Error listing tools from MCP server: ${(error as Error).message}`,
+      });
+    }
+  }
+
+  // callTool now accepts MCPClientParams, toolName, and args
+  async callTool(params: MCPClientParams, toolName: string, argsStr: any): Promise<any> {
+    const client = await this.getClient(params); // Get client using params
+
+    const args = safeParseJSON(argsStr);
+
+    log(`Calling tool "${toolName}" using client for params: %O with args: %O`, params, args);
+
+    try {
+      // Delegate the call to the MCPClient instance
+      const result = await client.callTool(toolName, args); // Pass args directly
+      log(`Tool "${toolName}" called successfully for params: %O, result: %O`, params, result);
+      const { content, isError } = result;
+      if (!isError) return content;
+
+      return result;
+    } catch (error) {
+      console.error(`Error calling tool "${toolName}" for params %O:`, params, error);
+      // Propagate a TRPCError
+      throw new TRPCError({
+        cause: error,
+        code: 'INTERNAL_SERVER_ERROR',
+        message: `Error calling tool "${toolName}" on MCP server: ${(error as Error).message}`,
+      });
+    }
+  }
+
+  // TODO: Consider adding methods for managing the client lifecycle if needed,
+  // e.g., explicitly closing clients on shutdown or after inactivity,
+  // although for serverless, on-demand creation/retrieval might be sufficient.
+
+  // TODO: Implement methods like listResources, getResource, listPrompts, getPrompt if needed,
+  // following the pattern of accepting MCPClientParams.
+
+  // --- Client Management (Replaces Connection Management) ---
+
+  // Private method to get or initialize a client based on parameters
+  private async getClient(params: MCPClientParams): Promise<MCPClient> {
+    const key = this.serializeParams(params); // Use custom serialization
+    log(`Attempting to get client for key: ${key} (params: %O)`, params);
+
+    if (this.clients.has(key)) {
+      log(`Returning cached client for key: ${key}`);
+      return this.clients.get(key)!;
+    }
+
+    log(`No cached client found for key: ${key}. Initializing new client.`);
+    try {
+      // Ensure stdio is only attempted in desktop/server environments within the client itself
+      // or add a check here if MCPClient doesn't handle it.
+      // Example check (adjust based on where environment check is best handled):
+      // if (params.type === 'stdio' && typeof window !== 'undefined') {
+      //   throw new Error('Stdio MCP type is not supported in browser environment.');
+      // }
+
+      const client = new MCPClient(params);
+      await client.initialize(); // Initialization logic should be within MCPClient
+      this.clients.set(key, client);
+      log(`New client initialized and cached for key: ${key}`);
+      return client;
+    } catch (error) {
+      console.error(`Failed to initialize MCP client for key ${key}:`, error);
+      // Do not cache failed initializations
+      throw new TRPCError({
+        cause: error,
+        code: 'INTERNAL_SERVER_ERROR',
+        message: `Failed to initialize MCP client: ${(error as Error).message}`,
+      });
+    }
+  }
+
+  // Custom serialization function to ensure consistent keys
+  private serializeParams(params: MCPClientParams): string {
+    const sortedKeys = Object.keys(params).sort();
+    const sortedParams: Record<string, any> = {};
+
+    for (const key of sortedKeys) {
+      const value = (params as any)[key];
+      // Sort the 'args' array if it exists
+      if (key === 'args' && Array.isArray(value)) {
+        sortedParams[key] = JSON.stringify(key);
+      } else {
+        sortedParams[key] = value;
+      }
+    }
+
+    return JSON.stringify(sortedParams);
+  }
+
+  async getStreamableMcpServerManifest(
+    identifier: string,
+    url: string,
+  ): 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,
+      meta: {
+        avatar: 'MCP_AVATAR',
+        description: `${identifier} MCP server has ${tools.length} tools, like "${tools[0]?.name}"`,
+        title: identifier,
+      },
+      // TODO: temporary
+      type: 'mcp' as any,
+    };
+  }
+}
+
+// Export a singleton instance
+export const mcpService = new MCPService();

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

@@ -0,0 +1,36 @@
+import { toolsClient } from '@/libs/trpc/client';
+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;
+
+    return toolsClient.mcp.callTool.mutate(
+      { args, params: { ...plugin.customParams?.mcp, name: identifier } as any, toolName: apiName },
+      { signal },
+    );
+  }
+
+  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();

package/src/services/topic/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 topicService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : clientService;
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
+    ? new ServerService()
+    : clientService;

package/src/services/user/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,6 +8,8 @@ const clientService =
   process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new DeprecatedService();
 
 export const userService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : clientService;
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
+    ? new ServerService()
+    : clientService;
 
 export const userClientService = clientService;

package/src/store/chat/slices/plugin/action.ts

@@ -8,6 +8,7 @@ import { StateCreator } from 'zustand/vanilla';
 import { LOADING_FLAT } from '@/const/message';
 import { PLUGIN_SCHEMA_API_MD5_PREFIX, PLUGIN_SCHEMA_SEPARATOR } from '@/const/plugin';
 import { chatService } from '@/services/chat';
+import { mcpService } from '@/services/mcp';
 import { messageService } from '@/services/message';
 import { ChatStore } from '@/store/chat/store';
 import { useToolStore } from '@/store/tool';
@@ -41,6 +42,7 @@ export interface ChatPluginAction {
   invokeBuiltinTool: (id: string, payload: ChatToolPayload) => Promise<void>;
   invokeDefaultTypePlugin: (id: string, payload: any) => Promise<string | undefined>;
   invokeMarkdownTypePlugin: (id: string, payload: ChatToolPayload) => Promise<void>;
+  invokeMCPTypePlugin: (id: string, payload: ChatToolPayload) => Promise<string | undefined>;
 
   invokeStandaloneTypePlugin: (id: string, payload: ChatToolPayload) => Promise<void>;
 
@@ -271,7 +273,7 @@ export const chatPlugin: StateCreator<
       // trigger the plugin call
       const data = await get().internal_invokeDifferentTypePlugin(id, payload);
 
-      if ((payload.type === 'default' || payload.type === 'builtin') && data) {
+      if (data && !['markdown', 'standalone'].includes(payload.type)) {
         shouldCreateMessage = true;
         latestToolId = id;
       }
@@ -328,7 +330,9 @@ export const chatPlugin: StateCreator<
 
     const updateAssistantMessage = async () => {
       if (!assistantMessage) return;
-      await messageService.updateMessage(assistantMessage!.id, { tools: assistantMessage?.tools });
+      await messageService.updateMessage(assistantMessage!.id, {
+        tools: assistantMessage?.tools,
+      });
     };
 
     await Promise.all([
@@ -438,11 +442,51 @@ export const chatPlugin: StateCreator<
         return await get().invokeBuiltinTool(id, payload);
       }
 
+      // @ts-ignore
+      case 'mcp': {
+        return await get().invokeMCPTypePlugin(id, payload);
+      }
+
       default: {
         return await get().invokeDefaultTypePlugin(id, payload);
       }
     }
   },
+  invokeMCPTypePlugin: async (id, payload) => {
+    const { internal_updateMessageContent, refreshMessages, internal_togglePluginApiCalling } =
+      get();
+    let data: string = '';
+
+    try {
+      const abortController = internal_togglePluginApiCalling(
+        true,
+        id,
+        n('fetchPlugin/start') as string,
+      );
+
+      const result = await mcpService.invokeMcpToolCall(payload, {
+        signal: abortController?.signal,
+      });
+      if (!!result) data = result;
+    } catch (error) {
+      console.log(error);
+      const err = error as Error;
+
+      // ignore the aborted request error
+      if (!err.message.includes('The user aborted a request.')) {
+        await messageService.updateMessageError(id, error as any);
+        await refreshMessages();
+      }
+    }
+
+    internal_togglePluginApiCalling(false, id, n('fetchPlugin/end') as string);
+    // 如果报错则结束了
+    if (!data) return;
+
+    await internal_updateMessageContent(id, data);
+
+    return data;
+  },
 
   internal_togglePluginApiCalling: (loading, id, action) => {
     return get().internal_toggleLoadingArrays('pluginApiLoadingIds', loading, id, action);