@lobehub/chat 1.96.19 → 1.97.0

package/src/hooks/useMCPCategory.tsx

@@ -0,0 +1,133 @@
+import {
+  BriefcaseIcon,
+  CheckSquareIcon,
+  CloudIcon,
+  CodeIcon,
+  CoffeeIcon,
+  DollarSignIcon,
+  GamepadIcon,
+  GraduationCapIcon,
+  HammerIcon,
+  ImageIcon,
+  LayoutPanelTopIcon,
+  LeafIcon,
+  MapIcon,
+  NewspaperIcon,
+  SearchIcon,
+  UsersIcon,
+} from 'lucide-react';
+import { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { McpCategory } from '@/types/discover';
+
+export const useCategory = () => {
+  const { t } = useTranslation('discover');
+  return useMemo(
+    () => [
+      {
+        icon: LayoutPanelTopIcon,
+        key: McpCategory.All,
+        label: t('mcp.categories.all.name'),
+        title: t('mcp.categories.all.description'),
+      },
+      {
+        icon: CodeIcon,
+        key: McpCategory.Developer,
+        label: t('mcp.categories.developer.name'),
+        title: t('mcp.categories.developer.description'),
+      },
+      {
+        icon: CheckSquareIcon,
+        key: McpCategory.Productivity,
+        label: t('mcp.categories.productivity.name'),
+        title: t('mcp.categories.productivity.description'),
+      },
+      {
+        icon: HammerIcon,
+        key: McpCategory.Tools,
+        label: t('mcp.categories.tools.name'),
+        title: t('mcp.categories.tools.description'),
+      },
+      {
+        icon: SearchIcon,
+        key: McpCategory.WebSearch,
+        label: t('mcp.categories.web-search.name'),
+        title: t('mcp.categories.web-search.description'),
+      },
+      {
+        icon: ImageIcon,
+        key: McpCategory.MediaGenerate,
+        label: t('mcp.categories.media-generate.name'),
+        title: t('mcp.categories.media-generate.description'),
+      },
+      {
+        icon: BriefcaseIcon,
+        key: McpCategory.Business,
+        label: t('mcp.categories.business.name'),
+        title: t('mcp.categories.business.description'),
+      },
+      {
+        icon: GraduationCapIcon,
+        key: McpCategory.ScienceEducation,
+        label: t('mcp.categories.science-education.name'),
+        title: t('mcp.categories.science-education.description'),
+      },
+      {
+        icon: DollarSignIcon,
+        key: McpCategory.StocksFinance,
+        label: t('mcp.categories.stocks-finance.name'),
+        title: t('mcp.categories.stocks-finance.description'),
+      },
+      {
+        icon: NewspaperIcon,
+        key: McpCategory.News,
+        label: t('mcp.categories.news.name'),
+        title: t('mcp.categories.news.description'),
+      },
+      {
+        icon: UsersIcon,
+        key: McpCategory.Social,
+        label: t('mcp.categories.social.name'),
+        title: t('mcp.categories.social.description'),
+      },
+      {
+        icon: GamepadIcon,
+        key: McpCategory.GamingEntertainment,
+        label: t('mcp.categories.gaming-entertainment.name'),
+        title: t('mcp.categories.gaming-entertainment.description'),
+      },
+      {
+        icon: CoffeeIcon,
+        key: McpCategory.Lifestyle,
+        label: t('mcp.categories.lifestyle.name'),
+        title: t('mcp.categories.lifestyle.description'),
+      },
+      {
+        icon: LeafIcon,
+        key: McpCategory.HealthWellness,
+        label: t('mcp.categories.health-wellness.name'),
+        title: t('mcp.categories.health-wellness.description'),
+      },
+      {
+        icon: MapIcon,
+        key: McpCategory.TravelTransport,
+        label: t('mcp.categories.travel-transport.name'),
+        title: t('mcp.categories.travel-transport.description'),
+      },
+      {
+        icon: CloudIcon,
+        key: McpCategory.Weather,
+        label: t('mcp.categories.weather.name'),
+        title: t('mcp.categories.weather.description'),
+      },
+    ],
+    [t],
+  );
+};
+
+export const useCategoryItem = (key?: McpCategory) => {
+  const items = useCategory();
+  if (!key) return;
+  return items.find((item) => item.key === key);
+};

package/src/hooks/useQuery.ts

@@ -0,0 +1,8 @@
+import { useSearchParams } from 'next/navigation';
+import qs from 'query-string';
+import { useMemo } from 'react';
+
+export const useQuery = () => {
+  const rawQuery = useSearchParams();
+  return useMemo(() => qs.parse(rawQuery.toString()), [rawQuery]);
+};

package/src/hooks/useQueryRoute.test.ts

@@ -11,6 +11,13 @@ vi.mock('next/navigation', () => ({
   })),
 }));
 
+vi.mock('nextjs-toploader/app', () => ({
+  useRouter: vi.fn(() => ({
+    push: vi.fn((href) => href),
+    replace: vi.fn((href) => href),
+  })),
+}));
+
 vi.mock('@/utils/env', () => ({
   isOnServerSide: false,
 }));

package/src/hooks/useQueryRoute.ts

@@ -1,4 +1,4 @@
-import { useRouter } from 'next/navigation';
+import { useRouter } from 'nextjs-toploader/app';
 import qs, { type ParsedQuery } from 'query-string';
 import { useMemo } from 'react';
 
@@ -18,7 +18,10 @@ interface GenHrefOptions extends QueryRouteOptions {
 }
 
 const genHref = ({ hash, replace, url, prevQuery = {}, query = {} }: GenHrefOptions): string => {
-  let href = qs.stringifyUrl({ query: replace ? query : { ...prevQuery, ...query }, url });
+  let href = qs.stringifyUrl(
+    { query: replace ? query : { ...prevQuery, ...query }, url },
+    { skipNull: true },
+  );
 
   if (!isOnServerSide && hash) {
     href = [href, hash || location?.hash?.slice(1)].filter(Boolean).join('#');
@@ -34,7 +37,6 @@ export const useQueryRoute = () => {
     () => ({
       push: (url: string, options: QueryRouteOptions = {}) => {
         const prevQuery = qs.parse(window.location.search);
-
         return router.push(genHref({ prevQuery, url, ...options }));
       },
       replace: (url: string, options: QueryRouteOptions = {}) => {

package/src/libs/mcp/client.ts

@@ -7,17 +7,158 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.d.ts';
 import type { Progress } from '@modelcontextprotocol/sdk/types.js';
 import debug from 'debug';
+import { spawn } from 'node:child_process';
 
-import { MCPClientParams, McpTool } from './types';
+import {
+  MCPClientParams,
+  MCPError,
+  McpPrompt,
+  McpResource,
+  McpTool,
+  createMCPError,
+} from './types';
 
 const log = debug('lobe-mcp:client');
+// MCP tool call timeout (milliseconds), configurable via the environment variable MCP_TOOL_TIMEOUT, default is 60000
+// Parse MCP_TOOL_TIMEOUT, only use if it's a valid positive number, otherwise fallback to default 60000
+const MCP_TOOL_TIMEOUT = (() => {
+  const val = Number(process.env.MCP_TOOL_TIMEOUT);
+  return Number.isFinite(val) && val > 0 ? val : 60_000;
+})();
+
+/**
+ * 预检查 stdio 命令，捕获详细的错误信息
+ */
+async function preCheckStdioCommand(params: {
+  args: string[];
+  command: string;
+  env?: Record<string, string>;
+}): Promise<{
+  error?: MCPError;
+  success: boolean;
+}> {
+  return new Promise((resolve) => {
+    log('Pre-checking stdio command: %s with args: %O', params.command, params.args);
+
+    const child = spawn(params.command, params.args, {
+      env: {
+        ...process.env,
+        ...getDefaultEnvironment(),
+        ...params.env,
+      },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let resolved = false;
+
+    // 设置超时时间 (5秒)
+    const timeout = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        child.kill('SIGTERM');
+        resolve({
+          error: createMCPError('INITIALIZATION_TIMEOUT', 'MCP service initialization timeout', {
+            errorLog: stderr || 'No stderr output',
+            params: {
+              args: params.args,
+              command: params.command,
+            },
+            step: 'precheck_timeout',
+          }),
+          success: false,
+        });
+      }
+    }, 5000);
+
+    // 收集 stdout
+    child.stdout?.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    // 收集 stderr - 这是关键部分
+    child.stderr?.on('data', (data) => {
+      stderr += data.toString();
+      log('Captured stderr: %s', data.toString());
+    });
+
+    child.on('error', (error) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        log('Process spawn error: %O', error);
+        resolve({
+          error: createMCPError('PROCESS_SPAWN_ERROR', 'Failed to start MCP service process', {
+            originalError: error.message,
+            params: {
+              args: params.args,
+              command: params.command,
+            },
+            step: 'process_spawn',
+          }),
+          success: false,
+        });
+      }
+    });
+
+    child.on('exit', (code, signal) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+
+        if (code === 0) {
+          log('Pre-check successful, stdout: %s', stdout);
+          resolve({ success: true });
+        } else {
+          log('Pre-check failed with code: %d, stderr: %s', code, stderr);
+          resolve({
+            error: createMCPError('CONNECTION_FAILED', 'MCP service startup failed', {
+              errorLog: stderr,
+              params: {
+                args: params.args,
+                command: params.command,
+              },
+              process: {
+                exitCode: code || undefined,
+                signal: signal || undefined,
+              },
+              step: 'process_exit',
+            }),
+            success: false,
+          });
+        }
+      }
+    });
+
+    // 发送简单的 JSON-RPC 初始化消息来测试连接
+    try {
+      const initMessage =
+        JSON.stringify({
+          id: 1,
+          jsonrpc: '2.0',
+          method: 'initialize',
+          params: {
+            clientInfo: { name: 'lobe-mcp-precheck', version: '1.0.0' },
+            protocolVersion: '2024-11-05',
+          },
+        }) + '\n';
+
+      child.stdin?.write(initMessage);
+      child.stdin?.end();
+    } catch (writeError) {
+      log('Failed to write to stdin: %O', writeError);
+    }
+  });
+}
 
 export class MCPClient {
   private mcp: Client;
   private transport: Transport;
+  private params: MCPClientParams;
 
   constructor(params: MCPClientParams) {
-    log('Creating MCPClient with connection: %O', params);
+    this.params = params;
     this.mcp = new Client({ name: 'lobehub-mcp-client', version: '1.0.0' });
 
     switch (params.type) {
@@ -26,8 +167,9 @@ export class MCPClient {
         this.transport = new StreamableHTTPClientTransport(new URL(params.url));
         break;
       }
+
       case 'stdio': {
-        log('Using Stdio transport with command: %s and args: %O', params.command, params.args);
+        log('Using Stdio transport with command: %s , args: %O', params.command, params.args);
 
         this.transport = new StdioClientTransport({
           args: params.args,
@@ -39,8 +181,15 @@ export class MCPClient {
         });
         break;
       }
+
       default: {
-        const err = new Error(`Unsupported MCP connection type: ${(params as any).type}`);
+        const err = createMCPError(
+          'VALIDATION_ERROR',
+          `Unsupported MCP connection type: ${(params as any).type}`,
+          {
+            params: { type: (params as any).type },
+          },
+        );
         log('Error creating client: %O', err);
         throw err;
       }
@@ -54,12 +203,61 @@ export class MCPClient {
       await this.mcp.connect(this.transport, { onprogress: options.onProgress });
       log('MCP connection initialized.');
     } catch (e) {
+      log('MCP connection failed:', e);
+
+      // 对于 stdio 连接失败，尝试预检查命令以获取详细错误信息
+      if (this.params.type === 'stdio') {
+        log('Attempting to pre-check stdio command for detailed error information...');
+
+        const preCheckResult = await preCheckStdioCommand({
+          args: this.params.args,
+          command: this.params.command,
+          env: this.params.env,
+        });
+
+        if (!preCheckResult.success && preCheckResult.error) {
+          log('Detailed error captured: %O', preCheckResult.error);
+          throw preCheckResult.error;
+        }
+      }
+
+      // For other connection types or when pre-check doesn't provide more information
       if ((e as any).code === -32_000) {
-        throw new Error('Fail to connecting MCP Server, please check your configuration.');
+        throw createMCPError(
+          'CONNECTION_FAILED',
+          'Failed to connect to MCP server, please check your configuration',
+          {
+            originalError: (e as Error).message,
+            params:
+              this.params.type === 'stdio'
+                ? {
+                    args: this.params.args,
+                    command: this.params.command,
+                    type: this.params.type,
+                  }
+                : {
+                    type: this.params.type,
+                  },
+            step: 'mcp_connect',
+          },
+        );
       }
 
-      log('MCP connection failed:', e);
-      throw e;
+      // Wrap other unknown errors
+      throw createMCPError('UNKNOWN_ERROR', 'Unknown error occurred', {
+        originalError: (e as Error).message,
+        params:
+          this.params.type === 'stdio'
+            ? {
+                args: this.params.args,
+                command: this.params.command,
+                type: this.params.type,
+              }
+            : {
+                type: this.params.type,
+              },
+        step: 'mcp_connect',
+      });
     }
   }
 
@@ -80,15 +278,69 @@ export class MCPClient {
   }
 
   async listTools() {
-    log('Listing tools...');
-    const { tools } = await this.mcp.listTools();
-    log('Listed tools: %O', tools);
-    return tools as McpTool[];
+    try {
+      log('Listing tools...');
+      const { tools } = await this.mcp.listTools();
+      log('Listed tools: %O', tools);
+      return tools as McpTool[];
+    } catch (e) {
+      log('Listed tools error: %O', e);
+      return [];
+    }
+  }
+
+  async listResources() {
+    try {
+      log('Listing resources...');
+      const { resources } = await this.mcp.listResources();
+      log('Listed resources: %O', resources);
+      return resources as McpResource[];
+    } catch (e) {
+      log('Listed resources: %O', e);
+      return [];
+    }
+  }
+
+  async listPrompts() {
+    try {
+      log('Listing prompts...');
+      const { prompts } = await this.mcp.listPrompts();
+      log('Listed prompts: %O', prompts);
+      return prompts as McpPrompt[];
+    } catch (e) {
+      log('Listed prompts: %O', e);
+      return [];
+    }
+  }
+
+  async listManifests() {
+    const capabilities = this.mcp.getServerCapabilities();
+    log('get capabilities: %O', capabilities);
+
+    const [tools, prompts, resources] = await Promise.all([
+      this.listTools(),
+      this.listPrompts(),
+      this.listResources(),
+    ]);
+
+    const manifest = {
+      prompts: prompts.length === 0 ? undefined : prompts,
+      resources: resources.length === 0 ? undefined : resources,
+      title: this.mcp.getServerVersion()?.title,
+      tools: tools.length === 0 ? undefined : tools,
+      version: this.mcp.getServerVersion()?.version?.replace('v', ''),
+    };
+
+    log('Listed Manifest: %O', manifest);
+
+    return manifest;
   }
 
   async callTool(toolName: string, args: any) {
-    log('Calling tool: %s with args: %O', toolName, args);
-    const result = await this.mcp.callTool({ arguments: args, name: toolName });
+    log('Calling tool: %s with args: %O, timeout: %O', toolName, args, MCP_TOOL_TIMEOUT);
+    const result = await this.mcp.callTool({ arguments: args, name: toolName }, undefined, {
+      timeout: MCP_TOOL_TIMEOUT,
+    });
     log('Tool call result: %O', result);
     return result;
   }

package/src/libs/mcp/types.ts

@@ -11,6 +11,25 @@ export interface McpTool {
   name: string;
 }
 
+export interface McpResource {
+  description?: string;
+  mimeType?: string;
+  name: string;
+  uri: string;
+}
+
+export interface McpPromptArgument {
+  description?: string;
+  name: string;
+  required?: boolean;
+}
+
+export interface McpPrompt {
+  arguments?: McpPromptArgument[];
+  description?: string;
+  name: string;
+}
+
 interface HttpMCPClientParams {
   name: string;
   type: 'http';
@@ -26,3 +45,83 @@ export interface StdioMCPParams {
 }
 
 export type MCPClientParams = HttpMCPClientParams | StdioMCPParams;
+
+export interface MCPErrorData {
+  message: string;
+  /**
+   * 结构化的错误元数据
+   */
+  metadata?: {
+    errorLog?: string;
+
+    /**
+     * 原始错误信息
+     */
+    originalError?: string;
+    /**
+     * MCP 连接参数
+     */
+    params?: {
+      args?: string[];
+      command?: string;
+      type?: string;
+    };
+
+    /**
+     * 进程相关信息
+     */
+    process?: {
+      exitCode?: number;
+      signal?: string;
+    };
+
+    /**
+     * 错误发生的步骤
+     */
+    step?: string;
+
+    /**
+     * 时间戳
+     */
+    timestamp?: number;
+  };
+
+  /**
+   * 错误类型
+   */
+  type:
+    | 'CONNECTION_FAILED'
+    | 'PROCESS_SPAWN_ERROR'
+    | 'INITIALIZATION_TIMEOUT'
+    | 'VALIDATION_ERROR'
+    | 'UNKNOWN_ERROR';
+}
+
+/**
+ * 结构化的 MCP 错误信息
+ */
+export interface MCPError extends Error {
+  data: MCPErrorData;
+}
+
+/**
+ * 创建结构化的 MCP 错误
+ */
+export function createMCPError(
+  type: MCPErrorData['type'],
+  message: string,
+  metadata?: MCPErrorData['metadata'],
+): MCPError {
+  const error = new Error(message) as MCPError;
+
+  error.data = {
+    message,
+    metadata: {
+      timestamp: Date.now(),
+      ...metadata,
+    },
+    type,
+  };
+
+  return error;
+}

package/src/libs/trpc/client/desktop.ts

@@ -1,12 +1,11 @@
-import { createTRPCClient, httpBatchLink } from '@trpc/client';
+import { createTRPCClient, httpLink } from '@trpc/client';
 import superjson from 'superjson';
 
 import type { DesktopRouter } from '@/server/routers/desktop';
 
 export const desktopClient = createTRPCClient<DesktopRouter>({
   links: [
-    httpBatchLink({
-      maxURLLength: 2083,
+    httpLink({
       transformer: superjson,
       url: '/trpc/desktop',
     }),