@lobehub/chat 0.107.16 → 0.109.0

package/src/store/tool/slices/customPlugin/action.test.ts

@@ -0,0 +1,164 @@
+import { act, renderHook } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { CustomPlugin } from '@/types/plugin';
+
+import { useToolStore } from '../../store';
+import { defaultCustomPlugin } from './initialState';
+import { CustomPluginListDispatch } from './reducers/customPluginList';
+
+beforeEach(() => {
+  vi.resetAllMocks();
+});
+
+describe('useToolStore:customPlugin', () => {
+  describe('deleteCustomPlugin', () => {
+    it('should delete custom plugin and related settings', async () => {
+      // 设置初始状态和 mock 函数
+      const deletePluginSettingsMock = vi.fn();
+      act(() => {
+        useToolStore.setState({
+          // ...其他状态
+          customPluginList: [{ identifier: 'test-plugin' } as CustomPlugin],
+          deletePluginSettings: deletePluginSettingsMock,
+        });
+      });
+
+      const { result } = renderHook(() => useToolStore());
+      const pluginId = 'test-plugin';
+
+      act(() => {
+        result.current.deleteCustomPlugin(pluginId);
+      });
+
+      expect(deletePluginSettingsMock).toHaveBeenCalledWith(pluginId);
+      expect(result.current.customPluginList).toEqual([]);
+    });
+  });
+
+  describe('dispatchCustomPluginList', () => {
+    it('should update the custom plugin list based on the dispatched action', () => {
+      const initialState = {
+        customPluginList: [],
+      };
+      act(() => {
+        useToolStore.setState(initialState);
+      });
+
+      const payload = {
+        type: 'addItem',
+        plugin: { identifier: 'plugin1', meta: { title: 'Test Plugin' } },
+      } as CustomPluginListDispatch;
+
+      const { result } = renderHook(() => useToolStore());
+
+      act(() => {
+        result.current.dispatchCustomPluginList(payload);
+      });
+
+      expect(useToolStore.getState().customPluginList).toEqual([
+        { identifier: 'plugin1', meta: { title: 'Test Plugin' } },
+      ]);
+    });
+
+    it('should return same if the type is not in dispatch', () => {
+      const initialState = {
+        customPluginList: [],
+      };
+      act(() => {
+        useToolStore.setState(initialState);
+      });
+
+      const payload = {
+        type: 'adddItem',
+        plugin: { identifier: 'plugin1', meta: { title: 'Test Plugin' } },
+      } as unknown as CustomPluginListDispatch;
+
+      const { result } = renderHook(() => useToolStore());
+
+      act(() => {
+        result.current.dispatchCustomPluginList(payload);
+      });
+
+      expect(useToolStore.getState().customPluginList).toEqual([]);
+    });
+  });
+
+  describe('saveToCustomPluginList', () => {
+    it('should add a plugin to the custom plugin list and reset newCustomPlugin', async () => {
+      const newPlugin = { identifier: 'plugin2', meta: { title: 'New Plugin' } } as CustomPlugin;
+      act(() => {
+        useToolStore.setState({
+          customPluginList: [],
+          newCustomPlugin: newPlugin,
+        });
+      });
+
+      const { result } = renderHook(() => useToolStore());
+
+      act(() => {
+        result.current.saveToCustomPluginList(newPlugin);
+      });
+
+      expect(result.current.customPluginList).toEqual([newPlugin]);
+      expect(result.current.newCustomPlugin).toEqual(defaultCustomPlugin);
+    });
+  });
+  describe('updateCustomPlugin', () => {
+    it('should update a specific plugin in the custom plugin list and reinstall the plugin', () => {
+      const pluginId = 'test-plugin';
+      const old = {
+        identifier: pluginId,
+        meta: { title: 'Old Plugin', avatar: '🍎' },
+      } as CustomPlugin;
+
+      const installPluginMock = vi.fn();
+
+      act(() => {
+        useToolStore.setState({
+          customPluginList: [old],
+          installPlugin: installPluginMock,
+        });
+      });
+
+      const { result } = renderHook(() => useToolStore());
+
+      const updatedPlugin = {
+        identifier: pluginId,
+        meta: { title: 'Updated Plugin', avatar: '🥒' },
+      } as CustomPlugin;
+
+      act(() => {
+        result.current.updateCustomPlugin(pluginId, updatedPlugin);
+      });
+
+      expect(result.current.customPluginList).toEqual([updatedPlugin]);
+      expect(installPluginMock).toHaveBeenCalledWith(pluginId);
+    });
+  });
+
+  describe('updateNewCustomPlugin', () => {
+    it('should update the newCustomPlugin state with the provided values', () => {
+      const initialNewCustomPlugin = {
+        identifier: 'plugin3',
+        meta: { title: 'Initial Plugin' },
+      } as CustomPlugin;
+      const updates = { meta: { title: 'Updated Name' } } as Partial<CustomPlugin>;
+      const expectedNewCustomPlugin = { ...initialNewCustomPlugin, ...updates };
+
+      act(() => {
+        useToolStore.setState({
+          newCustomPlugin: initialNewCustomPlugin,
+        });
+      });
+
+      const { result } = renderHook(() => useToolStore());
+
+      act(() => {
+        result.current.updateNewCustomPlugin(updates);
+      });
+
+      expect(useToolStore.getState().newCustomPlugin).toEqual(expectedNewCustomPlugin);
+    });
+  });
+});

package/src/store/{plugin → tool}/slices/customPlugin/action.ts

@@ -4,7 +4,7 @@ import { StateCreator } from 'zustand/vanilla';
 import { CustomPlugin } from '@/types/plugin';
 import { setNamespace } from '@/utils/storeDebug';
 
-import { PluginStore } from '../../store';
+import { ToolStore } from '../../store';
 import { defaultCustomPlugin } from './initialState';
 import { CustomPluginListDispatch, devPluginListReducer } from './reducers/customPluginList';
 
@@ -22,7 +22,7 @@ export interface CustomPluginAction {
 }
 
 export const createCustomPluginSlice: StateCreator<
-  PluginStore,
+  ToolStore,
   [['zustand/devtools', never]],
   [],
   CustomPluginAction

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

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+
+import { ToolStoreState } from '../../initialState';
+import { customPluginSelectors } from './selectors';
+
+const mockState = {
+  pluginManifestMap: {
+    'plugin-1': {
+      identifier: 'plugin-1',
+      api: [{ name: 'api-1' }],
+      type: 'default',
+    },
+    'plugin-2': {
+      identifier: 'plugin-2',
+      api: [{ name: 'api-2' }],
+      type: 'default',
+    },
+  },
+  pluginManifestLoading: {
+    'plugin-1': false,
+    'plugin-2': true,
+  },
+  pluginList: [
+    {
+      identifier: 'plugin-1',
+      author: 'Author 1',
+      createAt: '2021-01-01',
+      meta: { avatar: 'avatar-url-1', title: 'Plugin 1' },
+      homepage: 'http://homepage-1.com',
+    },
+    {
+      identifier: 'plugin-2',
+      author: 'Author 2',
+      createAt: '2022-02-02',
+      meta: { avatar: 'avatar-url-2', title: 'Plugin 2' },
+      homepage: 'http://homepage-2.com',
+    },
+  ],
+  customPluginList: [],
+  pluginsSettings: {},
+} as unknown as ToolStoreState;
+
+describe('pluginSelectors', () => {
+  describe('isCustomPlugin', () => {
+    it('should return false for a non-custom plugin', () => {
+      const result = customPluginSelectors.isCustomPlugin('plugin-1')(mockState);
+      expect(result).toBe(false);
+    });
+
+    it('should return true for a custom plugin', () => {
+      const stateWithCustomPlugin = {
+        ...mockState,
+        customPluginList: [{ identifier: 'custom-plugin' }],
+      } as ToolStoreState;
+      const result = customPluginSelectors.isCustomPlugin('custom-plugin')(stateWithCustomPlugin);
+      expect(result).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,9 @@
+import { pluginHelpers } from '../../helpers';
+import type { ToolStoreState } from '../../initialState';
+
+const isCustomPlugin = (id: string) => (s: ToolStoreState) =>
+  pluginHelpers.isCustomPlugin(id, s.customPluginList);
+
+export const customPluginSelectors = {
+  isCustomPlugin,
+};

package/src/store/tool/slices/plugin/action.test.ts

@@ -0,0 +1,141 @@
+import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { LobeSessions } from '@/types/session';
+
+import { useToolStore } from '../../store';
+import { PluginDispatch } from './reducers/manifest';
+
+beforeEach(() => {
+  // Reset all mocks before each test
+  vi.resetAllMocks();
+});
+
+describe('useToolStore:plugin', () => {
+  describe('checkLocalEnabledPlugins', () => {
+    it('should call checkPluginsIsInstalled with unique plugins from sessions', async () => {
+      // Mock sessions with some plugins
+      const sessions = [
+        { config: { plugins: ['plugin1', 'plugin2'] } },
+        { config: { plugins: ['plugin2', 'plugin3'] } },
+      ] as LobeSessions;
+
+      // Mock implementation for useToolStore
+      const checkPluginsIsInstalledMock = vi.fn();
+      useToolStore.setState({ checkPluginsIsInstalled: checkPluginsIsInstalledMock });
+
+      const { result } = renderHook(() => useToolStore());
+
+      // Call the action with our mock sessions
+      await act(async () => {
+        await result.current.checkLocalEnabledPlugins(sessions);
+      });
+
+      // Verify that checkPluginsIsInstalled was called with the correct unique plugins
+      expect(checkPluginsIsInstalledMock).toHaveBeenCalledWith(['plugin1', 'plugin2', 'plugin3']);
+    });
+
+    it('should not call checkPluginsIsInstalled if sessions have no plugins', async () => {
+      // Mock sessions with no plugins
+      const sessions = [
+        { config: { plugins: [] } },
+        { config: {} }, // config without plugins
+      ] as LobeSessions;
+
+      // Mock implementation for useToolStore
+      const checkPluginsIsInstalledMock = vi.fn();
+      useToolStore.setState({ checkPluginsIsInstalled: checkPluginsIsInstalledMock });
+
+      const { result } = renderHook(() => useToolStore());
+
+      // Call the action with our mock sessions
+      await act(async () => {
+        await result.current.checkLocalEnabledPlugins(sessions);
+      });
+
+      // Verify that checkPluginsIsInstalled was not called
+      expect(checkPluginsIsInstalledMock).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('deletePluginSettings', () => {
+    it('should delete the settings for a given plugin', () => {
+      const pluginId = 'test-plugin';
+      useToolStore.setState({
+        pluginsSettings: {
+          [pluginId]: { setting1: 'value1' },
+        },
+      });
+
+      const { result } = renderHook(() => useToolStore());
+
+      act(() => {
+        result.current.deletePluginSettings(pluginId);
+      });
+
+      expect(useToolStore.getState().pluginsSettings[pluginId]).toBeUndefined();
+    });
+  });
+
+  describe('dispatchPluginManifest', () => {
+    it('should update the pluginManifestMap with the given payload', () => {
+      const payload: PluginDispatch = {
+        type: 'addManifest',
+        id: 'plugin1',
+        plugin: { identifier: 'plugin1' } as LobeChatPluginManifest,
+      };
+      useToolStore.setState({
+        pluginManifestMap: {},
+      });
+
+      const { result } = renderHook(() => useToolStore());
+
+      act(() => {
+        result.current.dispatchPluginManifest(payload);
+      });
+
+      expect(useToolStore.getState().pluginManifestMap).toHaveProperty(payload.id);
+      expect(useToolStore.getState().pluginManifestMap[payload.id]).toEqual(payload.plugin);
+    });
+  });
+
+  describe('updatePluginSettings', () => {
+    it('should update settings for a given plugin', () => {
+      const pluginId = 'test-plugin';
+      const newSettings = { setting1: 'new-value' };
+      useToolStore.setState({
+        pluginsSettings: {
+          [pluginId]: { setting1: 'value1' },
+        },
+      });
+
+      const { result } = renderHook(() => useToolStore());
+
+      act(() => {
+        result.current.updatePluginSettings(pluginId, newSettings);
+      });
+
+      expect(useToolStore.getState().pluginsSettings[pluginId]).toEqual(newSettings);
+    });
+  });
+
+  describe('resetPluginSettings', () => {
+    it('should reset all plugin settings', () => {
+      useToolStore.setState({
+        pluginsSettings: {
+          plugin1: { setting1: 'value1' },
+          plugin2: { setting2: 'value2' },
+        },
+      });
+
+      const { result } = renderHook(() => useToolStore());
+
+      act(() => {
+        result.current.resetPluginSettings();
+      });
+
+      expect(useToolStore.getState().pluginsSettings).toEqual({});
+    });
+  });
+});

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

@@ -0,0 +1,95 @@
+import { produce } from 'immer';
+import { merge, uniq } from 'lodash-es';
+import useSWR, { SWRResponse } from 'swr';
+import { StateCreator } from 'zustand/vanilla';
+
+import { pluginStoreSelectors } from '@/store/tool/selectors';
+import { LobeSessions } from '@/types/session';
+import { setNamespace } from '@/utils/storeDebug';
+
+import { ToolStore } from '../../store';
+import { PluginDispatch, pluginManifestReducer } from './reducers/manifest';
+
+const n = setNamespace('plugin');
+
+/**
+ * 插件接口
+ */
+export interface PluginAction {
+  checkLocalEnabledPlugins: (sessions: LobeSessions) => Promise<void>;
+  checkPluginsIsInstalled: (plugins: string[]) => Promise<void>;
+  deletePluginSettings: (id: string) => void;
+  dispatchPluginManifest: (payload: PluginDispatch) => void;
+  resetPluginSettings: () => void;
+  updatePluginSettings: <T>(id: string, settings: Partial<T>) => void;
+  useCheckPluginsIsInstalled: (plugins: string[]) => SWRResponse;
+}
+
+export const createPluginSlice: StateCreator<
+  ToolStore,
+  [['zustand/devtools', never]],
+  [],
+  PluginAction
+> = (set, get) => ({
+  checkLocalEnabledPlugins: async (sessions) => {
+    const { checkPluginsIsInstalled } = get();
+
+    let enabledPlugins: string[] = [];
+
+    for (const session of sessions) {
+      const plugins = session.config.plugins;
+      if (!plugins || plugins.length === 0) continue;
+
+      enabledPlugins = [...enabledPlugins, ...plugins];
+    }
+
+    const plugins = uniq(enabledPlugins);
+
+    if (plugins.length === 0) return;
+    await checkPluginsIsInstalled(plugins);
+  },
+  checkPluginsIsInstalled: async (plugins) => {
+    // if there is no plugins, just skip.
+    if (plugins.length === 0) return;
+
+    const { loadPluginStore, installPlugins } = get();
+
+    // check if the store is empty
+    // if it is, we need to load the plugin store
+    if (pluginStoreSelectors.onlinePluginStore(get()).length === 0) {
+      await loadPluginStore();
+    }
+
+    await installPlugins(plugins);
+
+    set({ manifestPrepared: true }, false, n('checkPluginsIsInstalled'));
+  },
+  deletePluginSettings: (id) => {
+    set(
+      produce((draft) => {
+        draft.pluginsSettings[id] = undefined;
+      }),
+      false,
+      n('deletePluginSettings'),
+    );
+  },
+  dispatchPluginManifest: (payload) => {
+    const { pluginManifestMap } = get();
+    const nextManifest = pluginManifestReducer(pluginManifestMap, payload);
+
+    set({ pluginManifestMap: nextManifest }, false, n('dispatchPluginManifest', payload));
+  },
+  resetPluginSettings: () => {
+    set({ pluginsSettings: {} }, false, n('resetPluginSettings'));
+  },
+  updatePluginSettings: (id, settings) => {
+    set(
+      produce((draft) => {
+        draft.pluginsSettings[id] = merge({}, draft.pluginsSettings[id], settings);
+      }),
+      false,
+      n('updatePluginSettings'),
+    );
+  },
+  useCheckPluginsIsInstalled: (plugins) => useSWR(plugins, get().checkPluginsIsInstalled),
+});

package/src/store/{plugin → tool}/slices/plugin/initialState.ts

@@ -1,22 +1,15 @@
-import { LobeChatPluginMeta } from '@lobehub/chat-plugin-sdk';
-
 import { PluginManifestMap } from '@/types/plugin';
 
-export type PluginManifestLoadingState = Record<string, boolean>;
 export type PluginsSettings = Record<string, any>;
 
 export interface PluginState {
   manifestPrepared: boolean;
-  pluginList: LobeChatPluginMeta[];
-  pluginManifestLoading: PluginManifestLoadingState;
   pluginManifestMap: PluginManifestMap;
   pluginsSettings: PluginsSettings;
 }
 
 export const initialPluginState: PluginState = {
   manifestPrepared: false,
-  pluginList: [],
-  pluginManifestLoading: {},
   pluginManifestMap: {},
   pluginsSettings: {},
 };

package/src/store/{plugin → tool/slices/plugin}/selectors.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { PluginStoreState } from './initialState';
+import { ToolStoreState } from '../../initialState';
 import { pluginSelectors } from './selectors';
 
 const mockState = {
@@ -38,7 +38,7 @@ const mockState = {
   ],
   customPluginList: [],
   pluginsSettings: {},
-} as unknown as PluginStoreState;
+} as unknown as ToolStoreState;
 
 describe('pluginSelectors', () => {
   describe('enabledSchema', () => {
@@ -58,27 +58,6 @@ describe('pluginSelectors', () => {
       expect(result).toEqual(mockState.pluginManifestMap['plugin-1']);
     });
   });
-  describe('getPluginManifestLoadingStatus', () => {
-    it('success', () => {
-      const result = pluginSelectors.getPluginManifestLoadingStatus('plugin-1')(mockState);
-      expect(result).toBe('success');
-    });
-    it('loading', () => {
-      let result = pluginSelectors.getPluginManifestLoadingStatus('plugin-2')(mockState);
-      expect(result).toBe('loading');
-    });
-    it('error', () => {
-      let result = pluginSelectors.getPluginManifestLoadingStatus('plugin-3')(mockState);
-      expect(result).toBe('error');
-    });
-  });
-
-  describe('onlinePluginStore', () => {
-    it('should return the online plugin list', () => {
-      const result = pluginSelectors.onlinePluginStore(mockState);
-      expect(result).toEqual(mockState.pluginList);
-    });
-  });
 
   describe('pluginList', () => {
     it('should return the combined list of pluginList and customPluginList', () => {
@@ -111,7 +90,7 @@ describe('pluginSelectors', () => {
       const stateWithCustomPlugin = {
         ...mockState,
         customPluginList: [customPlugin],
-      } as PluginStoreState;
+      } as ToolStoreState;
       const result = pluginSelectors.getDevPluginById('custom-plugin')(stateWithCustomPlugin);
       expect(result).toEqual(customPlugin);
     });
@@ -129,22 +108,6 @@ describe('pluginSelectors', () => {
     });
   });
 
-  describe('isCustomPlugin', () => {
-    it('should return false for a non-custom plugin', () => {
-      const result = pluginSelectors.isCustomPlugin('plugin-1')(mockState);
-      expect(result).toBe(false);
-    });
-
-    it('should return true for a custom plugin', () => {
-      const stateWithCustomPlugin = {
-        ...mockState,
-        customPluginList: [{ identifier: 'custom-plugin' }],
-      } as PluginStoreState;
-      const result = pluginSelectors.isCustomPlugin('custom-plugin')(stateWithCustomPlugin);
-      expect(result).toBe(true);
-    });
-  });
-
   describe('displayPluginList', () => {
     it('should return a list of plugins with display information', () => {
       const result = pluginSelectors.displayPluginList(mockState);
@@ -177,7 +140,7 @@ describe('pluginSelectors', () => {
             ui: true,
           },
         },
-      } as unknown as PluginStoreState;
+      } as unknown as ToolStoreState;
       const result = pluginSelectors.hasPluginUI('ui-plugin')(stateWithUIPlugin);
       expect(result).toBe(true);
     });

package/src/store/{plugin → tool/slices/plugin}/selectors.ts

@@ -3,12 +3,12 @@ import { uniqBy } from 'lodash-es';
 import { PLUGIN_SCHEMA_SEPARATOR } from '@/const/plugin';
 import { ChatCompletionFunctions } from '@/types/openai/chat';
 
-import { pluginHelpers } from './helpers';
-import type { PluginStoreState } from './initialState';
+import { pluginHelpers } from '../../helpers';
+import type { ToolStoreState } from '../../initialState';
 
 const enabledSchema =
   (enabledPlugins: string[] = []) =>
-  (s: PluginStoreState): ChatCompletionFunctions[] => {
+  (s: ToolStoreState): ChatCompletionFunctions[] => {
     // 如果不存在 enabledPlugins，那么全部不启用
     if (!enabledPlugins) return [];
 
@@ -34,34 +34,29 @@ const enabledSchema =
     return uniqBy(list, 'name');
   };
 
-const onlinePluginStore = (s: PluginStoreState) => s.pluginList;
+const pluginList = (s: ToolStoreState) => [...s.pluginList, ...s.customPluginList];
 
-const pluginList = (s: PluginStoreState) => [...s.pluginList, ...s.customPluginList];
-
-const getPluginMetaById = (id: string) => (s: PluginStoreState) =>
+const getPluginMetaById = (id: string) => (s: ToolStoreState) =>
   pluginHelpers.getPluginFormList(pluginList(s), id);
 
-const getDevPluginById = (id: string) => (s: PluginStoreState) =>
+const getDevPluginById = (id: string) => (s: ToolStoreState) =>
   s.customPluginList.find((i) => i.identifier === id);
 
-const getPluginManifestById = (id: string) => (s: PluginStoreState) => s.pluginManifestMap[id];
-const getPluginSettingsById = (id: string) => (s: PluginStoreState) => s.pluginsSettings[id];
+const getPluginManifestById = (id: string) => (s: ToolStoreState) => s.pluginManifestMap[id];
+const getPluginSettingsById = (id: string) => (s: ToolStoreState) => s.pluginsSettings[id];
 
 // 获取插件 manifest 加载状态
-const getPluginManifestLoadingStatus = (id: string) => (s: PluginStoreState) => {
+const getPluginManifestLoadingStatus = (id: string) => (s: ToolStoreState) => {
   const manifest = getPluginManifestById(id)(s);
 
-  if (s.pluginManifestLoading[id]) return 'loading';
+  if (s.pluginInstallLoading[id]) return 'loading';
 
   if (!manifest) return 'error';
 
   if (!!manifest) return 'success';
 };
 
-const isCustomPlugin = (id: string) => (s: PluginStoreState) =>
-  pluginHelpers.isCustomPlugin(id, s.customPluginList);
-
-const displayPluginList = (s: PluginStoreState) =>
+const displayPluginList = (s: ToolStoreState) =>
   pluginList(s).map((p) => ({
     author: p.author,
     avatar: p.meta?.avatar,
@@ -72,12 +67,15 @@ const displayPluginList = (s: PluginStoreState) =>
     title: pluginHelpers.getPluginTitle(p.meta),
   }));
 
-const hasPluginUI = (id: string) => (s: PluginStoreState) => {
+const hasPluginUI = (id: string) => (s: ToolStoreState) => {
   const manifest = getPluginManifestById(id)(s);
 
   return !!manifest?.ui;
 };
 
+const installedPlugins = (s: ToolStoreState) => Object.values(s.pluginManifestMap);
+const isPluginInstalled = (id: string) => (s: ToolStoreState) => !!s.pluginManifestMap[id];
+
 export const pluginSelectors = {
   displayPluginList,
   enabledSchema,
@@ -87,7 +85,7 @@ export const pluginSelectors = {
   getPluginMetaById,
   getPluginSettingsById,
   hasPluginUI,
-  isCustomPlugin,
-  onlinePluginStore,
+  installedPlugins,
+  isPluginInstalled,
   pluginList,
 };