@lobehub/lobehub 2.0.0-next.160 → 2.0.0-next.161

package/src/store/tool/slices/klavisStore/selectors.test.ts

@@ -0,0 +1,371 @@
+import { describe, expect, it } from 'vitest';
+
+import { initialState } from '../../initialState';
+import { ToolStore } from '../../store';
+import { klavisStoreSelectors } from './selectors';
+import { KlavisServerStatus } from './types';
+
+describe('klavisStoreSelectors', () => {
+  describe('getServers', () => {
+    it('should return empty array when no servers exist', () => {
+      const state = { ...initialState } as ToolStore;
+      const result = klavisStoreSelectors.getServers(state);
+      expect(result).toEqual([]);
+    });
+
+    it('should return all servers', () => {
+      const servers = [
+        {
+          identifier: 'gmail',
+          serverName: 'Gmail',
+          instanceId: 'inst-1',
+          serverUrl: 'https://klavis.ai/gmail',
+          status: KlavisServerStatus.CONNECTED,
+          isAuthenticated: true,
+          createdAt: Date.now(),
+        },
+        {
+          identifier: 'github',
+          serverName: 'GitHub',
+          instanceId: 'inst-2',
+          serverUrl: 'https://klavis.ai/github',
+          status: KlavisServerStatus.PENDING_AUTH,
+          isAuthenticated: false,
+          createdAt: Date.now(),
+        },
+      ];
+      const state = { ...initialState, servers } as ToolStore;
+      const result = klavisStoreSelectors.getServers(state);
+      expect(result).toEqual(servers);
+    });
+  });
+
+  describe('getConnectedServers', () => {
+    it('should return only connected servers', () => {
+      const servers = [
+        {
+          identifier: 'gmail',
+          serverName: 'Gmail',
+          instanceId: 'inst-1',
+          serverUrl: 'https://klavis.ai/gmail',
+          status: KlavisServerStatus.CONNECTED,
+          isAuthenticated: true,
+          createdAt: Date.now(),
+        },
+        {
+          identifier: 'github',
+          serverName: 'GitHub',
+          instanceId: 'inst-2',
+          serverUrl: 'https://klavis.ai/github',
+          status: KlavisServerStatus.PENDING_AUTH,
+          isAuthenticated: false,
+          createdAt: Date.now(),
+        },
+        {
+          identifier: 'slack',
+          serverName: 'Slack',
+          instanceId: 'inst-3',
+          serverUrl: 'https://klavis.ai/slack',
+          status: KlavisServerStatus.ERROR,
+          isAuthenticated: false,
+          createdAt: Date.now(),
+        },
+      ];
+      const state = { ...initialState, servers } as ToolStore;
+      const result = klavisStoreSelectors.getConnectedServers(state);
+      expect(result).toHaveLength(1);
+      expect(result[0].serverName).toBe('Gmail');
+    });
+
+    it('should return empty array when no servers are connected', () => {
+      const servers = [
+        {
+          identifier: 'github',
+          serverName: 'GitHub',
+          instanceId: 'inst-2',
+          serverUrl: 'https://klavis.ai/github',
+          status: KlavisServerStatus.PENDING_AUTH,
+          isAuthenticated: false,
+          createdAt: Date.now(),
+        },
+      ];
+      const state = { ...initialState, servers } as ToolStore;
+      const result = klavisStoreSelectors.getConnectedServers(state);
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('getPendingAuthServers', () => {
+    it('should return only pending auth servers', () => {
+      const servers = [
+        {
+          identifier: 'gmail',
+          serverName: 'Gmail',
+          instanceId: 'inst-1',
+          serverUrl: 'https://klavis.ai/gmail',
+          status: KlavisServerStatus.CONNECTED,
+          isAuthenticated: true,
+          createdAt: Date.now(),
+        },
+        {
+          identifier: 'github',
+          serverName: 'GitHub',
+          instanceId: 'inst-2',
+          serverUrl: 'https://klavis.ai/github',
+          status: KlavisServerStatus.PENDING_AUTH,
+          isAuthenticated: false,
+          oauthUrl: 'https://oauth.klavis.ai/github',
+          createdAt: Date.now(),
+        },
+      ];
+      const state = { ...initialState, servers } as ToolStore;
+      const result = klavisStoreSelectors.getPendingAuthServers(state);
+      expect(result).toHaveLength(1);
+      expect(result[0].serverName).toBe('GitHub');
+    });
+  });
+
+  describe('getServerByIdentifier', () => {
+    it('should return server by identifier', () => {
+      const servers = [
+        {
+          identifier: 'gmail',
+          serverName: 'Gmail',
+          instanceId: 'inst-1',
+          serverUrl: 'https://klavis.ai/gmail',
+          status: KlavisServerStatus.CONNECTED,
+          isAuthenticated: true,
+          createdAt: Date.now(),
+        },
+      ];
+      const state = { ...initialState, servers } as ToolStore;
+      const result = klavisStoreSelectors.getServerByIdentifier('gmail')(state);
+      expect(result?.identifier).toBe('gmail');
+      expect(result?.serverName).toBe('Gmail');
+    });
+
+    it('should return undefined when server not found', () => {
+      const state = { ...initialState } as ToolStore;
+      const result = klavisStoreSelectors.getServerByIdentifier('non-existent')(state);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getAllServerIdentifiers', () => {
+    it('should return set of all server identifiers', () => {
+      const servers = [
+        {
+          identifier: 'gmail',
+          serverName: 'Gmail',
+          instanceId: 'inst-1',
+          serverUrl: 'https://klavis.ai/gmail',
+          status: KlavisServerStatus.CONNECTED,
+          isAuthenticated: true,
+          createdAt: Date.now(),
+        },
+        {
+          identifier: 'github',
+          serverName: 'GitHub',
+          instanceId: 'inst-2',
+          serverUrl: 'https://klavis.ai/github',
+          status: KlavisServerStatus.PENDING_AUTH,
+          isAuthenticated: false,
+          createdAt: Date.now(),
+        },
+      ];
+      const state = { ...initialState, servers } as ToolStore;
+      const result = klavisStoreSelectors.getAllServerIdentifiers(state);
+      expect(result).toEqual(new Set(['gmail', 'github']));
+    });
+  });
+
+  describe('isKlavisServer', () => {
+    it('should return true for existing server by identifier', () => {
+      const servers = [
+        {
+          identifier: 'gmail',
+          serverName: 'Gmail',
+          instanceId: 'inst-1',
+          serverUrl: 'https://klavis.ai/gmail',
+          status: KlavisServerStatus.CONNECTED,
+          isAuthenticated: true,
+          createdAt: Date.now(),
+        },
+      ];
+      const state = { ...initialState, servers } as ToolStore;
+      const result = klavisStoreSelectors.isKlavisServer('gmail')(state);
+      expect(result).toBe(true);
+    });
+
+    it('should return false for non-existing server', () => {
+      const state = { ...initialState } as ToolStore;
+      const result = klavisStoreSelectors.isKlavisServer('non-existent')(state);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('isServerLoading', () => {
+    it('should return true when server is loading', () => {
+      const state = {
+        ...initialState,
+        loadingServerIds: new Set(['gmail']),
+      } as ToolStore;
+      const result = klavisStoreSelectors.isServerLoading('gmail')(state);
+      expect(result).toBe(true);
+    });
+
+    it('should return false when server is not loading', () => {
+      const state = {
+        ...initialState,
+        loadingServerIds: new Set(),
+      } as ToolStore;
+      const result = klavisStoreSelectors.isServerLoading('gmail')(state);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('isToolExecuting', () => {
+    it('should return true when tool is executing', () => {
+      const state = {
+        ...initialState,
+        executingToolIds: new Set(['https://klavis.ai/gmail:sendEmail']),
+      } as ToolStore;
+      const result = klavisStoreSelectors.isToolExecuting(
+        'https://klavis.ai/gmail',
+        'sendEmail',
+      )(state);
+      expect(result).toBe(true);
+    });
+
+    it('should return false when tool is not executing', () => {
+      const state = {
+        ...initialState,
+        executingToolIds: new Set(),
+      } as ToolStore;
+      const result = klavisStoreSelectors.isToolExecuting(
+        'https://klavis.ai/gmail',
+        'sendEmail',
+      )(state);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('getAllTools', () => {
+    it('should return all tools from connected servers', () => {
+      const servers = [
+        {
+          identifier: 'gmail',
+          serverName: 'Gmail',
+          instanceId: 'inst-1',
+          serverUrl: 'https://klavis.ai/gmail',
+          status: KlavisServerStatus.CONNECTED,
+          isAuthenticated: true,
+          createdAt: Date.now(),
+          tools: [
+            { name: 'sendEmail', description: 'Send email', inputSchema: { type: 'object' } },
+            { name: 'readEmails', description: 'Read emails', inputSchema: { type: 'object' } },
+          ],
+        },
+        {
+          identifier: 'github',
+          serverName: 'GitHub',
+          instanceId: 'inst-2',
+          serverUrl: 'https://klavis.ai/github',
+          status: KlavisServerStatus.PENDING_AUTH,
+          isAuthenticated: false,
+          createdAt: Date.now(),
+          tools: [{ name: 'createPR', description: 'Create PR', inputSchema: { type: 'object' } }],
+        },
+      ];
+      const state = { ...initialState, servers } as ToolStore;
+      const result = klavisStoreSelectors.getAllTools(state);
+      // Only tools from connected server (Gmail) should be returned
+      expect(result).toHaveLength(2);
+      expect(result[0].name).toBe('sendEmail');
+      expect(result[0].serverName).toBe('Gmail');
+      expect(result[1].name).toBe('readEmails');
+    });
+
+    it('should return empty array when no connected servers have tools', () => {
+      const servers = [
+        {
+          identifier: 'gmail',
+          serverName: 'Gmail',
+          instanceId: 'inst-1',
+          serverUrl: 'https://klavis.ai/gmail',
+          status: KlavisServerStatus.CONNECTED,
+          isAuthenticated: true,
+          createdAt: Date.now(),
+        },
+      ];
+      const state = { ...initialState, servers } as ToolStore;
+      const result = klavisStoreSelectors.getAllTools(state);
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('klavisAsLobeTools', () => {
+    it('should convert Klavis servers to LobeTool format', () => {
+      const servers = [
+        {
+          identifier: 'gmail',
+          serverName: 'Gmail',
+          instanceId: 'inst-1',
+          serverUrl: 'https://klavis.ai/gmail',
+          status: KlavisServerStatus.CONNECTED,
+          isAuthenticated: true,
+          createdAt: Date.now(),
+          tools: [
+            { name: 'sendEmail', description: 'Send email', inputSchema: { type: 'object' } },
+          ],
+        },
+      ];
+      const state = { ...initialState, servers } as ToolStore;
+      const result = klavisStoreSelectors.klavisAsLobeTools(state);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].identifier).toBe('gmail');
+      expect(result[0].type).toBe('plugin');
+      expect(result[0].manifest.api).toHaveLength(1);
+      expect(result[0].manifest.api[0].name).toBe('sendEmail');
+      expect(result[0].manifest.meta.title).toBe('Gmail');
+    });
+
+    it('should not include disconnected servers', () => {
+      const servers = [
+        {
+          identifier: 'gmail',
+          serverName: 'Gmail',
+          instanceId: 'inst-1',
+          serverUrl: 'https://klavis.ai/gmail',
+          status: KlavisServerStatus.PENDING_AUTH,
+          isAuthenticated: false,
+          createdAt: Date.now(),
+          tools: [
+            { name: 'sendEmail', description: 'Send email', inputSchema: { type: 'object' } },
+          ],
+        },
+      ];
+      const state = { ...initialState, servers } as ToolStore;
+      const result = klavisStoreSelectors.klavisAsLobeTools(state);
+      expect(result).toEqual([]);
+    });
+
+    it('should not include servers without tools', () => {
+      const servers = [
+        {
+          identifier: 'gmail',
+          serverName: 'Gmail',
+          instanceId: 'inst-1',
+          serverUrl: 'https://klavis.ai/gmail',
+          status: KlavisServerStatus.CONNECTED,
+          isAuthenticated: true,
+          createdAt: Date.now(),
+        },
+      ];
+      const state = { ...initialState, servers } as ToolStore;
+      const result = klavisStoreSelectors.klavisAsLobeTools(state);
+      expect(result).toEqual([]);
+    });
+  });
+});

package/src/store/tool/slices/klavisStore/selectors.ts

@@ -0,0 +1,123 @@
+import { ToolStore } from '../../store';
+import { KlavisServer, KlavisServerStatus } from './types';
+
+/**
+ * Klavis Store Selectors
+ */
+export const klavisStoreSelectors = {
+  /**
+   * 获取所有 Klavis 服务器的 identifier 集合
+   */
+  getAllServerIdentifiers: (s: ToolStore): Set<string> => {
+    const servers = s.servers || [];
+    return new Set(servers.map((server) => server.identifier));
+  },
+
+  /**
+   * 获取所有可用的工具（来自所有已连接的服务器）
+   */
+  getAllTools: (s: ToolStore) => {
+    const connectedServers = klavisStoreSelectors.getConnectedServers(s);
+    return connectedServers.flatMap((server) =>
+      (server.tools || []).map((tool) => ({
+        ...tool,
+        // 工具仍然需要 serverName 用于 API 调用
+        serverName: server.serverName,
+      })),
+    );
+  },
+
+  /**
+   * 获取所有已连接的服务器
+   */
+  getConnectedServers: (s: ToolStore): KlavisServer[] =>
+    (s.servers || []).filter((server) => server.status === KlavisServerStatus.CONNECTED),
+
+  /**
+   * 获取所有待认证的服务器
+   */
+  getPendingAuthServers: (s: ToolStore): KlavisServer[] =>
+    (s.servers || []).filter((server) => server.status === KlavisServerStatus.PENDING_AUTH),
+
+  /**
+   * 根据 identifier 获取服务器
+   * @param identifier - 服务器标识符 (e.g., 'google-calendar')
+   */
+  getServerByIdentifier: (identifier: string) => (s: ToolStore) =>
+    s.servers?.find((server) => server.identifier === identifier),
+
+  /**
+   * 获取所有 Klavis 服务器
+   */
+  getServers: (s: ToolStore): KlavisServer[] => s.servers || [],
+
+  /**
+   * 检查给定的 identifier 是否是 Klavis 服务器
+   * @param identifier - 服务器标识符 (e.g., 'google-calendar')
+   */
+  isKlavisServer:
+    (identifier: string) =>
+    (s: ToolStore): boolean => {
+      const servers = s.servers || [];
+      return servers.some((server) => server.identifier === identifier);
+    },
+
+  /**
+   * 检查服务器是否正在加载
+   * @param identifier - 服务器标识符 (e.g., 'google-calendar')
+   */
+  isServerLoading: (identifier: string) => (s: ToolStore) =>
+    s.loadingServerIds?.has(identifier) || false,
+
+  /**
+   * 检查工具是否正在执行
+   */
+  isToolExecuting: (serverUrl: string, toolName: string) => (s: ToolStore) => {
+    const toolId = `${serverUrl}:${toolName}`;
+    return s.executingToolIds?.has(toolId) || false;
+  },
+
+  /**
+   * Get all Klavis tools as LobeTool format for agent use
+   * Converts Klavis tools into the format expected by ToolNameResolver
+   */
+  klavisAsLobeTools: (s: ToolStore) => {
+    const servers = s.servers || [];
+    const tools: any[] = [];
+
+    servers.forEach((server) => {
+      if (!server.tools || server.status !== KlavisServerStatus.CONNECTED) return;
+
+      // Create a manifest for this server that contains all its tools
+      const apis = server.tools.map((tool) => ({
+        description: tool.description || '',
+        name: tool.name,
+        parameters: tool.inputSchema || {},
+      }));
+
+      if (apis.length > 0) {
+        tools.push({
+          // 使用 identifier 作为存储和引用的标识符
+          identifier: server.identifier,
+          manifest: {
+            api: apis,
+            author: 'Klavis',
+            homepage: 'https://klavis.ai',
+            identifier: server.identifier,
+            meta: {
+              avatar: '☁️',
+              description: `Klavis MCP Server: ${server.serverName}`,
+              tags: ['klavis', 'mcp'],
+              title: server.serverName,
+            },
+            type: 'builtin',
+            version: '1.0.0',
+          },
+          type: 'plugin',
+        });
+      }
+    });
+
+    return tools;
+  },
+};

package/src/store/tool/slices/klavisStore/types.ts

@@ -0,0 +1,100 @@
+/**
+ * Klavis Server 连接状态
+ */
+export enum KlavisServerStatus {
+  /** 已连接，可以使用 */
+  CONNECTED = 'connected',
+  /** 连接失败 */
+  ERROR = 'error',
+  /** 未认证，需要完成 OAuth 流程 */
+  PENDING_AUTH = 'pending_auth',
+}
+
+/**
+ * Klavis 工具定义（MCP 格式）
+ */
+export interface KlavisTool {
+  /** 工具描述 */
+  description?: string;
+  /** 工具输入的 JSON Schema */
+  inputSchema: {
+    properties?: Record<string, any>;
+    required?: string[];
+    type: string;
+  };
+  /** 工具名称 */
+  name: string;
+}
+
+/**
+ * Klavis Server 实例
+ */
+export interface KlavisServer {
+  /** 创建时间戳 */
+  createdAt: number;
+  /** 错误信息（如果有） */
+  errorMessage?: string;
+  /** 服务器图标 URL */
+  icon?: string;
+  /**
+   * 标识符，用于存储到数据库（如 'google-calendar'）
+   * 格式：小写，空格替换为连字符
+   */
+  identifier: string;
+  /** Klavis 实例 ID */
+  instanceId: string;
+  /** 是否已认证 */
+  isAuthenticated: boolean;
+  /** OAuth 认证 URL */
+  oauthUrl?: string;
+  /**
+   * 服务器名称，用于调用 Klavis API（如 'Google Calendar'）
+   */
+  serverName: string;
+  /** 服务器 URL (用于连接和调用工具) */
+  serverUrl: string;
+  /** 连接状态 */
+  status: KlavisServerStatus;
+  /** 服务器提供的工具列表 */
+  tools?: KlavisTool[];
+}
+
+/**
+ * 创建 Klavis Server 的参数
+ */
+export interface CreateKlavisServerParams {
+  /**
+   * 标识符，用于存储到数据库（如 'google-calendar'）
+   */
+  identifier: string;
+  /**
+   * 服务器名称，用于调用 Klavis API（如 'Google Calendar'）
+   */
+  serverName: string;
+  /** 用户 ID */
+  userId: string;
+}
+
+/**
+ * 调用 Klavis 工具的参数
+ */
+export interface CallKlavisToolParams {
+  /** Strata Server URL */
+  serverUrl: string;
+  /** 工具参数 */
+  toolArgs?: Record<string, unknown>;
+  /** 工具名称 */
+  toolName: string;
+}
+
+/**
+ * 调用 Klavis 工具的结果
+ */
+export interface CallKlavisToolResult {
+  /** 返回数据 */
+  data?: any;
+  /** 错误信息 */
+  error?: string;
+  /** 是否成功 */
+  success: boolean;
+}

package/src/store/tool/slices/plugin/selectors.ts

@@ -53,19 +53,22 @@ const installedPluginManifestList = (s: ToolStoreState) =>
     .filter((i) => !!i);
 
 const installedPluginMetaList = (s: ToolStoreState) =>
-  installedPlugins(s).map<InstallPluginMeta>((p) => ({
-    author: p.manifest?.author,
-    createdAt: p.manifest?.createdAt || (p.manifest as any)?.createAt,
-    homepage: p.manifest?.homepage,
-    identifier: p.identifier,
-    /*
-     * should remove meta
-     */
-    meta: getPluginMetaById(p.identifier)(s),
-    runtimeType: p.runtimeType,
-    type: p.source || p.type,
-    ...getPluginMetaById(p.identifier)(s),
-  }));
+  installedPlugins(s)
+    // 过滤掉 Klavis 插件（它们有自己的显示位置）
+    .filter((p) => !p.customParams?.klavis)
+    .map<InstallPluginMeta>((p) => ({
+      author: p.manifest?.author,
+      createdAt: p.manifest?.createdAt || (p.manifest as any)?.createAt,
+      homepage: p.manifest?.homepage,
+      identifier: p.identifier,
+      /*
+       * should remove meta
+       */
+      meta: getPluginMetaById(p.identifier)(s),
+      runtimeType: p.runtimeType,
+      type: p.source || p.type,
+      ...getPluginMetaById(p.identifier)(s),
+    }));
 const installedCustomPluginMetaList = (s: ToolStoreState) =>
   installedPluginMetaList(s).filter((p) => p.type === 'customPlugin');
 

package/src/store/tool/store.ts

@@ -6,6 +6,7 @@ import { createDevtools } from '../middleware/createDevtools';
 import { ToolStoreState, initialState } from './initialState';
 import { BuiltinToolAction, createBuiltinToolSlice } from './slices/builtin';
 import { CustomPluginAction, createCustomPluginSlice } from './slices/customPlugin';
+import { KlavisStoreAction, createKlavisStoreSlice } from './slices/klavisStore';
 import { PluginMCPStoreAction, createMCPPluginStoreSlice } from './slices/mcpStore';
 import { PluginAction, createPluginSlice } from './slices/plugin';
 import { PluginStoreAction, createPluginStoreSlice } from './slices/oldStore';
@@ -17,7 +18,8 @@ export type ToolStore = ToolStoreState &
   PluginAction &
   PluginStoreAction &
   BuiltinToolAction &
-  PluginMCPStoreAction;
+  PluginMCPStoreAction &
+  KlavisStoreAction;
 
 const createStore: StateCreator<ToolStore, [['zustand/devtools', never]]> = (...parameters) => ({
   ...initialState,
@@ -26,6 +28,7 @@ const createStore: StateCreator<ToolStore, [['zustand/devtools', never]]> = (...
   ...createPluginStoreSlice(...parameters),
   ...createBuiltinToolSlice(...parameters),
   ...createMCPPluginStoreSlice(...parameters),
+  ...createKlavisStoreSlice(...parameters),
 });
 
 //  ===============  Implement useStore ============ //