@lobehub/lobehub 2.0.0-next.26 → 2.0.0-next.28

package/src/store/tool/slices/mcpStore/action.ts

@@ -1,19 +1,21 @@
 import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
 import { PluginItem, PluginListResponse } from '@lobehub/market-sdk';
 import { TRPCClientError } from '@trpc/client';
+import debug from 'debug';
 import { produce } from 'immer';
 import { uniqBy } from 'lodash-es';
 import { gt, valid } from 'semver';
 import useSWR, { SWRResponse } from 'swr';
 import { StateCreator } from 'zustand/vanilla';
 
-import { CURRENT_VERSION } from '@/const/version';
+import { CURRENT_VERSION, isDesktop } from '@lobechat/const';
 import { MCPErrorData } from '@/libs/mcp/types';
 import { discoverService } from '@/services/discover';
 import { mcpService } from '@/services/mcp';
 import { pluginService } from '@/services/plugin';
 import { globalHelpers } from '@/store/global/helpers';
 import { mcpStoreSelectors } from '@/store/tool/selectors';
+import { McpConnectionType } from '@/types/discover';
 import {
   CheckMcpInstallResult,
   MCPErrorInfo,
@@ -28,8 +30,41 @@ import { setNamespace } from '@/utils/storeDebug';
 import { ToolStore } from '../../store';
 import { MCPStoreState } from './initialState';
 
+const log = debug('lobe-mcp:store:action');
+
 const n = setNamespace('mcpStore');
 
+const doesConfigSchemaRequireInput = (configSchema?: any) => {
+  if (!configSchema) return false;
+
+  const hasRequiredArray =
+    Array.isArray(configSchema.required) && configSchema.required.some(Boolean);
+
+  const hasRequiredProperty =
+    !!configSchema.properties &&
+    Object.values(configSchema.properties).some(
+      (property: any) => property && property.required === true,
+    );
+
+  return hasRequiredArray || hasRequiredProperty;
+};
+
+const toNonEmptyStringRecord = (input?: Record<string, any>) => {
+  if (!input) return undefined;
+
+  const entries = Object.entries(input).filter(
+    ([, value]) => value !== undefined && value !== null,
+  );
+
+  if (entries.length === 0) return undefined;
+
+  return entries.reduce<Record<string, string>>((acc, [key, value]) => {
+    acc[key] = typeof value === 'string' ? value : String(value);
+
+    return acc;
+  }, {});
+};
+
 // 测试连接结果类型
 export interface TestMcpConnectionResult {
   error?: string;
@@ -101,6 +136,7 @@ export const createMCPPluginStoreSlice: StateCreator<
 
   installMCPPlugin: async (identifier, options = {}) => {
     const { resume = false, config, skipDepsCheck } = options;
+    const normalizedConfig = toNonEmptyStringRecord(config);
     let plugin = mcpStoreSelectors.getPluginById(identifier)(get());
 
     if (!plugin || !plugin.manifestUrl) {
@@ -149,12 +185,8 @@ export const createMCPPluginStoreSlice: StateCreator<
         }
 
         data = configInfo.manifest;
-        connection = {
-          ...configInfo.connection,
-          config, // 合并用户提供的配置
-        };
+        connection = configInfo.connection ? { ...configInfo.connection } : undefined;
         result = configInfo.checkResult;
-        connection = configInfo.connection;
       } else {
         // 正常模式：从头开始安装
 
@@ -175,59 +207,137 @@ export const createMCPPluginStoreSlice: StateCreator<
           install: true,
         });
 
-        // 步骤 2: 检查安装环境
-        updateMCPInstallProgress(identifier, {
-          progress: 30,
-          step: MCPInstallStep.CHECKING_INSTALLATION,
+        const deploymentOptions: any[] = Array.isArray(data.deploymentOptions)
+          ? data.deploymentOptions
+          : [];
+
+        const httpOption = deploymentOptions.find(
+          (option) => option?.connection?.url && option?.connection?.type === 'http',
+        ) ||
+          deploymentOptions.find(
+            (option) => option?.connection?.url && !option?.connection?.type,
+          );
+
+        const hasNonHttpDeployment = deploymentOptions.some((option) => {
+          const type = option?.connection?.type;
+          if (!type && option?.connection?.url) return false;
+
+          return type && type !== 'http';
         });
 
-        // 检查是否已被取消
-        if (abortController.signal.aborted) {
-          return;
-        }
+        const shouldUseHttpDeployment = !!httpOption && (!hasNonHttpDeployment || !isDesktop);
 
-        result = await mcpService.checkInstallation(data, abortController.signal);
+        if (shouldUseHttpDeployment && httpOption) {
+          // ✅ HTTP 类型：跳过系统依赖检查，直接使用 URL
+          log('HTTP MCP detected, skipping system dependency check');
 
-        if (!result.success) {
-          updateMCPInstallProgress(identifier, undefined);
-          return;
-        }
+          connection = {
+            auth: httpOption.connection?.auth || { type: 'none' },
+            headers: httpOption.connection?.headers,
+            type: 'http',
+            url: httpOption.connection?.url,
+          };
+
+          log('Using HTTP connection: %O', { type: connection.type, url: connection.url });
 
-        // 步骤 3: 检查系统依赖是否满足
-        if (!skipDepsCheck && !result.allDependenciesMet) {
-          // 依赖不满足，暂停安装流程并显示依赖安装引导
+          const configSchema = httpOption.connection?.configSchema;
+          const needsConfig = doesConfigSchemaRequireInput(configSchema);
+
+          if (needsConfig && !normalizedConfig) {
+            updateMCPInstallProgress(identifier, {
+              configSchema,
+              connection,
+              manifest: data,
+              needsConfig: true,
+              progress: 50,
+              step: MCPInstallStep.CONFIGURATION_REQUIRED,
+            });
+
+            updateInstallLoadingState(identifier, undefined);
+            return false;
+          }
+        } else {
+          // ❌ stdio 类型：需要完整的系统依赖检查流程
+
+          // 步骤 2: 检查安装环境
           updateMCPInstallProgress(identifier, {
-            connection: result.connection,
-            manifest: data,
-            progress: 40,
-            step: MCPInstallStep.DEPENDENCIES_REQUIRED,
-            systemDependencies: result.systemDependencies,
+            progress: 30,
+            step: MCPInstallStep.CHECKING_INSTALLATION,
           });
 
-          // 暂停安装流程，等待用户安装依赖
-          updateInstallLoadingState(identifier, undefined);
-          return false; // 返回 false 表示需要安装依赖
+          // 检查是否已被取消
+          if (abortController.signal.aborted) {
+            return;
+          }
+
+          result = await mcpService.checkInstallation(data, abortController.signal);
+
+          if (!result.success) {
+            updateMCPInstallProgress(identifier, undefined);
+            return;
+          }
+
+          // 步骤 3: 检查系统依赖是否满足
+          if (!skipDepsCheck && !result.allDependenciesMet) {
+            // 依赖不满足，暂停安装流程并显示依赖安装引导
+            updateMCPInstallProgress(identifier, {
+              connection: result.connection,
+              manifest: data,
+              progress: 40,
+              step: MCPInstallStep.DEPENDENCIES_REQUIRED,
+              systemDependencies: result.systemDependencies,
+            });
+
+            // 暂停安装流程，等待用户安装依赖
+            updateInstallLoadingState(identifier, undefined);
+            return false; // 返回 false 表示需要安装依赖
+          }
+
+          // 步骤 4: 检查是否需要配置
+          if (result.needsConfig) {
+            // 需要配置，暂停安装流程
+            updateMCPInstallProgress(identifier, {
+              checkResult: result,
+              configSchema: result.configSchema,
+              connection: result.connection,
+              manifest: data,
+              needsConfig: true,
+              progress: 50,
+              step: MCPInstallStep.CONFIGURATION_REQUIRED,
+            });
+
+            // 暂停安装流程，等待用户配置
+            updateInstallLoadingState(identifier, undefined);
+            return false; // 返回 false 表示需要配置
+          }
+
+          connection = result.connection;
         }
+      }
 
-        // 步骤 4: 检查是否需要配置
-        if (result.needsConfig) {
-          // 需要配置，暂停安装流程
-          updateMCPInstallProgress(identifier, {
-            checkResult: result,
-            configSchema: result.configSchema,
-            connection: result.connection,
-            manifest: data,
-            needsConfig: true,
-            progress: 50,
-            step: MCPInstallStep.CONFIGURATION_REQUIRED,
-          });
+      let mergedHttpHeaders: Record<string, string> | undefined;
+      let mergedStdioEnv: Record<string, string> | undefined;
+
+      if (connection?.type === 'http') {
+        const baseHeaders = toNonEmptyStringRecord(connection.headers);
 
-          // 暂停安装流程，等待用户配置
-          updateInstallLoadingState(identifier, undefined);
-          return false; // 返回 false 表示需要配置
+        if (baseHeaders || normalizedConfig) {
+          mergedHttpHeaders = {
+            ...baseHeaders,
+            ...normalizedConfig,
+          };
         }
+      }
+
+      if (connection?.type === 'stdio') {
+        const baseEnv = toNonEmptyStringRecord(connection.env);
 
-        connection = result.connection;
+        if (baseEnv || normalizedConfig) {
+          mergedStdioEnv = {
+            ...baseEnv,
+            ...normalizedConfig,
+          };
+        }
       }
 
       // 获取服务器清单逻辑
@@ -251,7 +361,7 @@ export const createMCPPluginStoreSlice: StateCreator<
           {
             args: connection.args,
             command: connection.command!,
-            env: config,
+            env: mergedStdioEnv,
             name: identifier, // 将配置作为环境变量传递（resume 模式下）
           },
           { avatar: plugin.icon, description: plugin.description, name: data.name },
@@ -261,6 +371,8 @@ export const createMCPPluginStoreSlice: StateCreator<
       if (connection?.type === 'http') {
         manifest = await mcpService.getStreamableMcpServerManifest(
           {
+            auth: connection.auth,
+            headers: mergedHttpHeaders,
             identifier,
             metadata: {
               avatar: plugin.icon,
@@ -318,7 +430,7 @@ export const createMCPPluginStoreSlice: StateCreator<
         customParams: { mcp: connection },
         identifier: plugin.identifier,
         manifest: manifest,
-        settings: config,
+        settings: normalizedConfig,
         type: 'plugin',
       });
 
@@ -347,7 +459,7 @@ export const createMCPPluginStoreSlice: StateCreator<
           resources: (manifest as any).resources,
           tools: (manifest as any).tools,
         },
-        platform: result!.platform,
+        platform: result?.platform || process.platform,
         success: true,
         userAgent,
         version: manifest.version || data.version,
@@ -423,7 +535,7 @@ export const createMCPPluginStoreSlice: StateCreator<
         installDurationMs,
         installParams: connection,
         metadata: errorInfo.metadata,
-        platform: result!.platform,
+        platform: result?.platform || process.platform,
         success: false,
         userAgent,
         version: data?.version,
@@ -581,10 +693,22 @@ export const createMCPPluginStoreSlice: StateCreator<
 
   useFetchMCPPluginList: (params) => {
     const locale = globalHelpers.getCurrentLanguage();
+    const requestParams = isDesktop ? params : { ...params, connectionType: McpConnectionType.http };
+    const swrKeyParts = [
+      'useFetchMCPPluginList',
+      locale,
+      requestParams.page,
+      requestParams.pageSize,
+      requestParams.q,
+      requestParams.connectionType,
+    ];
+    const swrKey = swrKeyParts.filter((part) => part !== undefined && part !== null && part !== '')
+      .join('-');
+    const page = requestParams.page ?? 1;
 
     return useSWR<PluginListResponse>(
-      ['useFetchMCPPluginList', locale, ...Object.values(params)].filter(Boolean).join('-'),
-      () => discoverService.getMCPPluginList(params),
+      swrKey,
+      () => discoverService.getMCPPluginList(requestParams),
       {
         onSuccess(data) {
           set(
@@ -602,7 +726,7 @@ export const createMCPPluginStoreSlice: StateCreator<
               }
 
               // 累积数据逻辑
-              if (params.page === 1) {
+              if (page === 1) {
                 // 第一页，直接设置
                 draft.mcpPluginItems = uniqBy(data.items, 'identifier');
               } else {

package/src/store/tool/slices/oldStore/initialState.ts

@@ -1,4 +1,3 @@
-import { isDesktop } from '@/const/version';
 import { DiscoverPluginItem } from '@/types/discover';
 
 export type PluginInstallLoadingMap = Record<string, boolean | undefined>;
@@ -47,7 +46,7 @@ export const initialPluginStoreState: PluginStoreState = {
   // Plugin list state management initial values
   currentPluginPage: 1,
   displayMode: 'grid',
-  listType: isDesktop ? PluginStoreTabs.MCP : PluginStoreTabs.Plugin,
+  listType: PluginStoreTabs.MCP,
   oldPluginItems: [],
   pluginInstallLoading: {},
   pluginInstallProgress: {},

package/src/store/user/slices/common/action.test.ts

@@ -30,7 +30,7 @@ describe('createCommonSlice', () => {
       const avatar = 'data:image/png;base64,';
 
       const spyOn = vi.spyOn(result.current, 'refreshUserState');
-      const updateAvatarSpy = vi.spyOn(userService, 'updateAvatar').mockResolvedValue(undefined);
+      const updateAvatarSpy = vi.spyOn(userService, 'updateAvatar').mockResolvedValue({} as any);
 
       await act(async () => {
         await result.current.updateAvatar(avatar);

package/src/services/aiModel/server.test.ts

@@ -1,122 +0,0 @@
-import { AiProviderModelListItem } from 'model-bank';
-import { describe, expect, it, vi } from 'vitest';
-
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { ServerService } from './server';
-
-vi.mock('@/libs/trpc/client', () => ({
-  lambdaClient: {
-    aiModel: {
-      createAiModel: { mutate: vi.fn() },
-      getAiProviderModelList: { query: vi.fn() },
-      getAiModelById: { query: vi.fn() },
-      toggleModelEnabled: { mutate: vi.fn() },
-      updateAiModel: { mutate: vi.fn() },
-      batchUpdateAiModels: { mutate: vi.fn() },
-      batchToggleAiModels: { mutate: vi.fn() },
-      clearModelsByProvider: { mutate: vi.fn() },
-      clearRemoteModels: { mutate: vi.fn() },
-      updateAiModelOrder: { mutate: vi.fn() },
-      removeAiModel: { mutate: vi.fn() },
-    },
-  },
-}));
-
-describe('ServerService', () => {
-  const service = new ServerService();
-
-  it('should create AI model', async () => {
-    const params = {
-      id: 'test-id',
-      providerId: 'test-provider',
-      displayName: 'Test Model',
-    };
-    await service.createAiModel(params);
-    expect(vi.mocked(lambdaClient.aiModel.createAiModel.mutate)).toHaveBeenCalledWith(params);
-  });
-
-  it('should get AI provider model list', async () => {
-    await service.getAiProviderModelList('123');
-    expect(vi.mocked(lambdaClient.aiModel.getAiProviderModelList.query)).toHaveBeenCalledWith({
-      id: '123',
-    });
-  });
-
-  it('should get AI model by id', async () => {
-    await service.getAiModelById('123');
-    expect(vi.mocked(lambdaClient.aiModel.getAiModelById.query)).toHaveBeenCalledWith({
-      id: '123',
-    });
-  });
-
-  it('should toggle model enabled', async () => {
-    const params = { id: '123', providerId: 'test', enabled: true };
-    await service.toggleModelEnabled(params);
-    expect(vi.mocked(lambdaClient.aiModel.toggleModelEnabled.mutate)).toHaveBeenCalledWith(params);
-  });
-
-  it('should update AI model', async () => {
-    const value = { contextWindowTokens: 4000, displayName: 'Updated Model' };
-    await service.updateAiModel('123', 'openai', value);
-    expect(vi.mocked(lambdaClient.aiModel.updateAiModel.mutate)).toHaveBeenCalledWith({
-      id: '123',
-      providerId: 'openai',
-      value,
-    });
-  });
-
-  it('should batch update AI models', async () => {
-    const models: AiProviderModelListItem[] = [
-      {
-        id: '123',
-        enabled: true,
-        type: 'chat',
-      },
-    ];
-    await service.batchUpdateAiModels('provider1', models);
-    expect(vi.mocked(lambdaClient.aiModel.batchUpdateAiModels.mutate)).toHaveBeenCalledWith({
-      id: 'provider1',
-      models,
-    });
-  });
-
-  it('should batch toggle AI models', async () => {
-    const models = ['123', '456'];
-    await service.batchToggleAiModels('provider1', models, true);
-    expect(vi.mocked(lambdaClient.aiModel.batchToggleAiModels.mutate)).toHaveBeenCalledWith({
-      id: 'provider1',
-      models,
-      enabled: true,
-    });
-  });
-
-  it('should clear models by provider', async () => {
-    await service.clearModelsByProvider('provider1');
-    expect(vi.mocked(lambdaClient.aiModel.clearModelsByProvider.mutate)).toHaveBeenCalledWith({
-      providerId: 'provider1',
-    });
-  });
-
-  it('should clear remote models', async () => {
-    await service.clearRemoteModels('provider1');
-    expect(vi.mocked(lambdaClient.aiModel.clearRemoteModels.mutate)).toHaveBeenCalledWith({
-      providerId: 'provider1',
-    });
-  });
-
-  it('should update AI model order', async () => {
-    const items = [{ id: '123', sort: 1 }];
-    await service.updateAiModelOrder('provider1', items);
-    expect(vi.mocked(lambdaClient.aiModel.updateAiModelOrder.mutate)).toHaveBeenCalledWith({
-      providerId: 'provider1',
-      sortMap: items,
-    });
-  });
-
-  it('should delete AI model', async () => {
-    const params = { id: '123', providerId: 'openai' };
-    await service.deleteAiModel(params);
-    expect(vi.mocked(lambdaClient.aiModel.removeAiModel.mutate)).toHaveBeenCalledWith(params);
-  });
-});

package/src/services/aiModel/server.ts

@@ -1,51 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-import { IAiModelService } from '@/services/aiModel/type';
-
-export class ServerService implements IAiModelService {
-  createAiModel: IAiModelService['createAiModel'] = async (params) => {
-    return lambdaClient.aiModel.createAiModel.mutate(params);
-  };
-
-  getAiProviderModelList: IAiModelService['getAiProviderModelList'] = async (id) => {
-    return lambdaClient.aiModel.getAiProviderModelList.query({ id });
-  };
-
-  getAiModelById: IAiModelService['getAiModelById'] = async (id) => {
-    return lambdaClient.aiModel.getAiModelById.query({ id });
-  };
-
-  toggleModelEnabled: IAiModelService['toggleModelEnabled'] = async (params) => {
-    return lambdaClient.aiModel.toggleModelEnabled.mutate(params);
-  };
-
-  updateAiModel: IAiModelService['updateAiModel'] = async (id, providerId, value) => {
-    return lambdaClient.aiModel.updateAiModel.mutate({ id, providerId, value });
-  };
-
-  batchUpdateAiModels: IAiModelService['batchUpdateAiModels'] = async (id, models) => {
-    return lambdaClient.aiModel.batchUpdateAiModels.mutate({ id, models });
-  };
-
-  batchToggleAiModels: IAiModelService['batchToggleAiModels'] = async (id, models, enabled) => {
-    return lambdaClient.aiModel.batchToggleAiModels.mutate({ enabled, id, models });
-  };
-
-  clearModelsByProvider: IAiModelService['clearModelsByProvider'] = async (providerId) => {
-    return lambdaClient.aiModel.clearModelsByProvider.mutate({ providerId });
-  };
-
-  clearRemoteModels: IAiModelService['clearRemoteModels'] = async (providerId) => {
-    return lambdaClient.aiModel.clearRemoteModels.mutate({ providerId });
-  };
-
-  updateAiModelOrder: IAiModelService['updateAiModelOrder'] = async (providerId, items) => {
-    return lambdaClient.aiModel.updateAiModelOrder.mutate({ providerId, sortMap: items });
-  };
-
-  deleteAiModel: IAiModelService['deleteAiModel'] = async (params: {
-    id: string;
-    providerId: string;
-  }) => {
-    return lambdaClient.aiModel.removeAiModel.mutate(params);
-  };
-}

package/src/services/aiModel/type.ts

@@ -1,32 +0,0 @@
-/* eslint-disable typescript-sort-keys/interface */
-import {
-  AiModelSortMap,
-  AiProviderModelListItem,
-  CreateAiModelParams,
-  ToggleAiModelEnableParams,
-  UpdateAiModelParams,
-} from 'model-bank';
-
-export interface IAiModelService {
-  createAiModel: (params: CreateAiModelParams) => Promise<any>;
-
-  getAiProviderModelList: (id: string) => Promise<AiProviderModelListItem[]>;
-
-  getAiModelById: (id: string) => Promise<any>;
-
-  toggleModelEnabled: (params: ToggleAiModelEnableParams) => Promise<any>;
-
-  updateAiModel: (id: string, providerId: string, value: UpdateAiModelParams) => Promise<any>;
-
-  batchUpdateAiModels: (id: string, models: AiProviderModelListItem[]) => Promise<any>;
-
-  batchToggleAiModels: (id: string, models: string[], enabled: boolean) => Promise<any>;
-
-  clearRemoteModels: (providerId: string) => Promise<any>;
-
-  clearModelsByProvider: (providerId: string) => Promise<any>;
-
-  updateAiModelOrder: (providerId: string, items: AiModelSortMap[]) => Promise<any>;
-
-  deleteAiModel: (params: { id: string; providerId: string }) => Promise<any>;
-}

package/src/services/aiProvider/server.ts

@@ -1,43 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { IAiProviderService } from './type';
-
-export class ServerService implements IAiProviderService {
-  createAiProvider: IAiProviderService['createAiProvider'] = async (params) => {
-    return lambdaClient.aiProvider.createAiProvider.mutate(params);
-  };
-
-  getAiProviderList: IAiProviderService['getAiProviderList'] = async () => {
-    return lambdaClient.aiProvider.getAiProviderList.query();
-  };
-
-  getAiProviderById: IAiProviderService['getAiProviderById'] = async (id) => {
-    return lambdaClient.aiProvider.getAiProviderById.query({ id });
-  };
-
-  toggleProviderEnabled: IAiProviderService['toggleProviderEnabled'] = async (id, enabled) => {
-    return lambdaClient.aiProvider.toggleProviderEnabled.mutate({ enabled, id });
-  };
-
-  updateAiProvider: IAiProviderService['updateAiProvider'] = async (id, value) => {
-    return lambdaClient.aiProvider.updateAiProvider.mutate({ id, value });
-  };
-
-  updateAiProviderConfig: IAiProviderService['updateAiProviderConfig'] = async (id, value) => {
-    return lambdaClient.aiProvider.updateAiProviderConfig.mutate({ id, value });
-  };
-
-  updateAiProviderOrder: IAiProviderService['updateAiProviderOrder'] = async (items) => {
-    return lambdaClient.aiProvider.updateAiProviderOrder.mutate({ sortMap: items });
-  };
-
-  deleteAiProvider: IAiProviderService['deleteAiProvider'] = async (id) => {
-    return lambdaClient.aiProvider.removeAiProvider.mutate({ id });
-  };
-
-  getAiProviderRuntimeState: IAiProviderService['getAiProviderRuntimeState'] = async (
-    isLogin?: boolean,
-  ) => {
-    return lambdaClient.aiProvider.getAiProviderRuntimeState.query({ isLogin });
-  };
-}

package/src/services/aiProvider/type.ts

@@ -1,27 +0,0 @@
-import {
-  AiProviderDetailItem,
-  AiProviderRuntimeState,
-  AiProviderSortMap,
-  CreateAiProviderParams,
-  UpdateAiProviderConfigParams,
-} from '@/types/aiProvider';
-
-export interface IAiProviderService {
-  createAiProvider: (params: CreateAiProviderParams) => Promise<any>;
-
-  deleteAiProvider: (id: string) => Promise<any>;
-
-  getAiProviderById: (id: string) => Promise<AiProviderDetailItem | undefined>;
-
-  getAiProviderList: () => Promise<any>;
-
-  getAiProviderRuntimeState: (isLogin?: boolean) => Promise<AiProviderRuntimeState>;
-
-  toggleProviderEnabled: (id: string, enabled: boolean) => Promise<any>;
-
-  updateAiProvider: (id: string, value: any) => Promise<any>;
-
-  updateAiProviderConfig: (id: string, value: UpdateAiProviderConfigParams) => Promise<any>;
-
-  updateAiProviderOrder: (items: AiProviderSortMap[]) => Promise<any>;
-}