@lobehub/lobehub 2.0.0-next.235 → 2.0.0-next.237

package/src/app/[variants]/onboarding/index.tsx

@@ -1,5 +1,6 @@
 'use client';
 
+import { MAX_ONBOARDING_STEPS } from '@lobechat/types';
 import { Flexbox } from '@lobehub/ui';
 import { memo } from 'react';
 
@@ -40,7 +41,7 @@ const OnboardingPage = memo(() => {
       case 4: {
         return <ResponseLanguageStep onBack={goToPreviousStep} onNext={goToNextStep} />;
       }
-      case 5: {
+      case MAX_ONBOARDING_STEPS: {
         return <ProSettingsStep onBack={goToPreviousStep} />;
       }
       default: {

package/src/server/services/search/impls/exa/index.ts

@@ -47,7 +47,7 @@ export class ExaImpl implements SearchServiceImpl {
             };
           })()
         : {}),
-      category: // Exa 只支持 news 类型
+      category: // Exa only supports news type
       params?.searchCategories?.filter((cat) => ['news'].includes(cat))?.[0],
     };
 

package/src/server/services/search/impls/search1api/index.ts

@@ -41,7 +41,7 @@ export class Search1APIImpl implements SearchServiceImpl {
     const { searchEngines } = params;
 
     const defaultQueryParams: Search1APIQueryParams = {
-      crawl_results: 0, // 默认不做抓取
+      crawl_results: 0, // Default is no crawling
       image: false,
       max_results: 15, // Default max results
       query,

package/src/server/services/search/impls/tavily/index.ts

@@ -42,7 +42,7 @@ export class TavilyImpl implements SearchServiceImpl {
         params?.searchTimeRange && params.searchTimeRange !== 'anytime'
           ? params.searchTimeRange
           : undefined,
-      topic: // Tavily 只支持 news 和 general 两种类型
+      topic: // Tavily only supports news and general types
       params?.searchCategories?.filter((cat) => ['news', 'general'].includes(cat))?.[0],
     };
 

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

@@ -1,5 +1,5 @@
-import { act, renderHook } from '@testing-library/react';
-import { describe, expect, it, vi } from 'vitest';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { lambdaClient, toolsClient } from '@/libs/trpc/client';
 
@@ -8,6 +8,10 @@ import { KlavisServerStatus } from './types';
 
 vi.mock('zustand/traditional');
 
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
 vi.mock('@/libs/trpc/client', () => ({
   lambdaClient: {
     klavis: {
@@ -509,4 +513,165 @@ describe('klavisStore actions', () => {
       expect(lambdaClient.klavis.getServerInstance.query).toHaveBeenCalled();
     });
   });
+
+  describe('useFetchUserKlavisServers', () => {
+    it('should set isServersInit to true on success with empty data', async () => {
+      act(() => {
+        useToolStore.setState({
+          servers: [],
+          loadingServerIds: new Set(),
+          executingToolIds: new Set(),
+          isServersInit: false,
+        });
+      });
+
+      vi.mocked(lambdaClient.klavis.getKlavisPlugins.query).mockResolvedValue([]);
+
+      renderHook(() => useToolStore.getState().useFetchUserKlavisServers(true));
+
+      await waitFor(() => {
+        expect(useToolStore.getState().isServersInit).toBe(true);
+      });
+    });
+
+    it('should not fetch when disabled', () => {
+      act(() => {
+        useToolStore.setState({
+          servers: [],
+          loadingServerIds: new Set(),
+          executingToolIds: new Set(),
+          isServersInit: false,
+        });
+      });
+
+      vi.mocked(lambdaClient.klavis.getKlavisPlugins.query).mockClear();
+
+      renderHook(() => useToolStore.getState().useFetchUserKlavisServers(false));
+
+      expect(lambdaClient.klavis.getKlavisPlugins.query).not.toHaveBeenCalled();
+      expect(useToolStore.getState().isServersInit).toBe(false);
+    });
+  });
+
+  describe('server deduplication logic', () => {
+    it('should deduplicate servers by identifier when adding new servers', () => {
+      // This tests the deduplication logic used in useFetchUserKlavisServers onSuccess
+      act(() => {
+        useToolStore.setState({
+          servers: [
+            {
+              identifier: 'gmail',
+              serverName: 'Gmail',
+              instanceId: 'existing-inst',
+              serverUrl: 'https://klavis.ai/gmail',
+              status: KlavisServerStatus.CONNECTED,
+              isAuthenticated: true,
+              createdAt: Date.now(),
+            },
+          ],
+          loadingServerIds: new Set(),
+          executingToolIds: new Set(),
+          isServersInit: false,
+        });
+      });
+
+      // Simulate what onSuccess does
+      const incomingServers = [
+        {
+          identifier: 'gmail',
+          serverName: 'Gmail',
+          instanceId: 'new-inst',
+          serverUrl: 'https://klavis.ai/gmail',
+          status: KlavisServerStatus.CONNECTED,
+          isAuthenticated: true,
+          createdAt: Date.now(),
+        },
+        {
+          identifier: 'github',
+          serverName: 'GitHub',
+          instanceId: 'github-inst',
+          serverUrl: 'https://klavis.ai/github',
+          status: KlavisServerStatus.CONNECTED,
+          isAuthenticated: true,
+          createdAt: Date.now(),
+        },
+      ];
+
+      act(() => {
+        const existingServers = useToolStore.getState().servers;
+        const existingIdentifiers = new Set(existingServers.map((s) => s.identifier));
+        const newServers = incomingServers.filter((s) => !existingIdentifiers.has(s.identifier));
+
+        useToolStore.setState({
+          servers: [...existingServers, ...newServers],
+          isServersInit: true,
+        });
+      });
+
+      const finalServers = useToolStore.getState().servers;
+      expect(finalServers).toHaveLength(2);
+      // Existing gmail should keep its original instanceId
+      expect(finalServers.find((s) => s.identifier === 'gmail')?.instanceId).toBe('existing-inst');
+      // New github should be added
+      expect(finalServers.find((s) => s.identifier === 'github')?.instanceId).toBe('github-inst');
+      expect(useToolStore.getState().isServersInit).toBe(true);
+    });
+
+    it('should add all servers when none exist', () => {
+      act(() => {
+        useToolStore.setState({
+          servers: [],
+          loadingServerIds: new Set(),
+          executingToolIds: new Set(),
+          isServersInit: false,
+        });
+      });
+
+      const incomingServers = [
+        {
+          identifier: 'gmail',
+          serverName: 'Gmail',
+          instanceId: 'inst-1',
+          serverUrl: 'https://klavis.ai/gmail',
+          status: KlavisServerStatus.CONNECTED,
+          isAuthenticated: true,
+          createdAt: Date.now(),
+        },
+      ];
+
+      act(() => {
+        const existingServers = useToolStore.getState().servers;
+        const existingIdentifiers = new Set(existingServers.map((s) => s.identifier));
+        const newServers = incomingServers.filter((s) => !existingIdentifiers.has(s.identifier));
+
+        useToolStore.setState({
+          servers: [...existingServers, ...newServers],
+          isServersInit: true,
+        });
+      });
+
+      expect(useToolStore.getState().servers).toHaveLength(1);
+      expect(useToolStore.getState().isServersInit).toBe(true);
+    });
+
+    it('should set isServersInit even when no servers are added', () => {
+      act(() => {
+        useToolStore.setState({
+          servers: [],
+          loadingServerIds: new Set(),
+          executingToolIds: new Set(),
+          isServersInit: false,
+        });
+      });
+
+      // Simulate empty data case
+      act(() => {
+        useToolStore.setState({
+          isServersInit: true,
+        });
+      });
+
+      expect(useToolStore.getState().isServersInit).toBe(true);
+    });
+  });
 });

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

@@ -356,18 +356,19 @@ export const createKlavisStoreSlice: StateCreator<
       {
         fallbackData: [],
         onSuccess: (data) => {
-          if (data.length > 0) {
-            set(
-              produce((draft: KlavisStoreState) => {
+          set(
+            produce((draft: KlavisStoreState) => {
+              if (data.length > 0) {
                 // 使用 identifier 检查是否已存在
                 const existingIdentifiers = new Set(draft.servers.map((s) => s.identifier));
                 const newServers = data.filter((s) => !existingIdentifiers.has(s.identifier));
                 draft.servers = [...draft.servers, ...newServers];
-              }),
-              false,
-              n('useFetchUserKlavisServers'),
-            );
-          }
+              }
+              draft.isServersInit = true;
+            }),
+            false,
+            n('useFetchUserKlavisServers'),
+          );
         },
         revalidateOnFocus: false,
       },

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

@@ -9,6 +9,8 @@ import { type KlavisServer } from './types';
 export interface KlavisStoreState {
   /** 正在执行的工具调用 ID 集合 */
   executingToolIds: Set<string>;
+  /** 是否已完成初始化加载 */
+  isServersInit: boolean;
   /** 正在加载的服务器 ID 集合 */
   loadingServerIds: Set<string>;
   /** 已创建的 Klavis Server 列表 */
@@ -20,6 +22,7 @@ export interface KlavisStoreState {
  */
 export const initialKlavisStoreState: KlavisStoreState = {
   executingToolIds: new Set(),
+  isServersInit: false,
   loadingServerIds: new Set(),
   servers: [],
 };

package/src/store/user/slices/auth/action.ts

@@ -41,6 +41,7 @@ const fetchAuthProvidersData = async (): Promise<AuthProvidersData> => {
       accounts
         .filter((account) => account.providerId !== 'credential')
         .map(async (account) => {
+          // In theory, the id_token could be decrypted from the accounts table, but I found that better-auth on GitHub does not save the id_token
           const info = await accountInfo({
             query: { accountId: account.accountId },
           });

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

@@ -0,0 +1,342 @@
+import { CURRENT_ONBOARDING_VERSION } from '@lobechat/const';
+import { MAX_ONBOARDING_STEPS } from '@lobechat/types';
+import { act, renderHook } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { userService } from '@/services/user';
+import { useUserStore } from '@/store/user';
+
+import { initialOnboardingState } from './initialState';
+
+vi.mock('zustand/traditional');
+
+vi.mock('@/services/user', () => ({
+  userService: {
+    updateOnboarding: vi.fn(),
+  },
+}));
+
+describe('onboarding actions', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    act(() => {
+      useUserStore.setState({
+        ...initialOnboardingState,
+        onboarding: { currentStep: 1, version: CURRENT_ONBOARDING_VERSION },
+        refreshUserState: vi.fn(),
+      });
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('goToNextStep', () => {
+    it('should increment step and set localOnboardingStep', () => {
+      const { result } = renderHook(() => useUserStore());
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          onboarding: { currentStep: 1, version: CURRENT_ONBOARDING_VERSION },
+        });
+      });
+
+      act(() => {
+        result.current.goToNextStep();
+      });
+
+      expect(result.current.localOnboardingStep).toBe(2);
+    });
+
+    it('should not increment step when already at MAX_ONBOARDING_STEPS', () => {
+      const { result } = renderHook(() => useUserStore());
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          localOnboardingStep: MAX_ONBOARDING_STEPS,
+          onboarding: { currentStep: MAX_ONBOARDING_STEPS, version: CURRENT_ONBOARDING_VERSION },
+        });
+      });
+
+      act(() => {
+        result.current.goToNextStep();
+      });
+
+      // localOnboardingStep should remain at MAX_ONBOARDING_STEPS
+      expect(result.current.localOnboardingStep).toBe(MAX_ONBOARDING_STEPS);
+    });
+
+    it('should queue step update when incrementing', () => {
+      const { result } = renderHook(() => useUserStore());
+
+      const queueStepUpdateSpy = vi.spyOn(result.current, 'internal_queueStepUpdate');
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          onboarding: { currentStep: 2, version: CURRENT_ONBOARDING_VERSION },
+        });
+      });
+
+      act(() => {
+        result.current.goToNextStep();
+      });
+
+      expect(queueStepUpdateSpy).toHaveBeenCalledWith(3);
+    });
+
+    it('should not queue step update when at MAX_ONBOARDING_STEPS', () => {
+      const { result } = renderHook(() => useUserStore());
+
+      const queueStepUpdateSpy = vi.spyOn(result.current, 'internal_queueStepUpdate');
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          localOnboardingStep: MAX_ONBOARDING_STEPS,
+          onboarding: { currentStep: MAX_ONBOARDING_STEPS, version: CURRENT_ONBOARDING_VERSION },
+        });
+      });
+
+      act(() => {
+        result.current.goToNextStep();
+      });
+
+      expect(queueStepUpdateSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('goToPreviousStep', () => {
+    it('should decrement step and set localOnboardingStep', () => {
+      const { result } = renderHook(() => useUserStore());
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          localOnboardingStep: 3,
+          onboarding: { currentStep: 3, version: CURRENT_ONBOARDING_VERSION },
+        });
+      });
+
+      act(() => {
+        result.current.goToPreviousStep();
+      });
+
+      expect(result.current.localOnboardingStep).toBe(2);
+    });
+
+    it('should not decrement step when already at step 1', () => {
+      const { result } = renderHook(() => useUserStore());
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          localOnboardingStep: 1,
+          onboarding: { currentStep: 1, version: CURRENT_ONBOARDING_VERSION },
+        });
+      });
+
+      act(() => {
+        result.current.goToPreviousStep();
+      });
+
+      // localOnboardingStep should remain at 1
+      expect(result.current.localOnboardingStep).toBe(1);
+    });
+
+    it('should queue step update when decrementing', () => {
+      const { result } = renderHook(() => useUserStore());
+
+      const queueStepUpdateSpy = vi.spyOn(result.current, 'internal_queueStepUpdate');
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          localOnboardingStep: 3,
+          onboarding: { currentStep: 3, version: CURRENT_ONBOARDING_VERSION },
+        });
+      });
+
+      act(() => {
+        result.current.goToPreviousStep();
+      });
+
+      expect(queueStepUpdateSpy).toHaveBeenCalledWith(2);
+    });
+
+    it('should not queue step update when at step 1', () => {
+      const { result } = renderHook(() => useUserStore());
+
+      const queueStepUpdateSpy = vi.spyOn(result.current, 'internal_queueStepUpdate');
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          localOnboardingStep: 1,
+          onboarding: { currentStep: 1, version: CURRENT_ONBOARDING_VERSION },
+        });
+      });
+
+      act(() => {
+        result.current.goToPreviousStep();
+      });
+
+      expect(queueStepUpdateSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('internal_queueStepUpdate', () => {
+    it('should add task to empty queue and start processing', () => {
+      const { result } = renderHook(() => useUserStore());
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          stepUpdateQueue: [],
+        });
+      });
+
+      const processSpy = vi.spyOn(result.current, 'internal_processStepUpdateQueue');
+
+      act(() => {
+        result.current.internal_queueStepUpdate(2);
+      });
+
+      expect(result.current.stepUpdateQueue).toContain(2);
+      expect(processSpy).toHaveBeenCalled();
+    });
+
+    it('should add pending task when one task is executing', () => {
+      const { result } = renderHook(() => useUserStore());
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          stepUpdateQueue: [2],
+          isProcessingStepQueue: true,
+        });
+      });
+
+      act(() => {
+        result.current.internal_queueStepUpdate(3);
+      });
+
+      expect(result.current.stepUpdateQueue).toEqual([2, 3]);
+    });
+
+    it('should replace pending task when queue has two tasks', () => {
+      const { result } = renderHook(() => useUserStore());
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          stepUpdateQueue: [2, 3],
+          isProcessingStepQueue: true,
+        });
+      });
+
+      act(() => {
+        result.current.internal_queueStepUpdate(4);
+      });
+
+      expect(result.current.stepUpdateQueue).toEqual([2, 4]);
+    });
+  });
+
+  describe('internal_processStepUpdateQueue', () => {
+    it('should not process when already processing', async () => {
+      const { result } = renderHook(() => useUserStore());
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          stepUpdateQueue: [2],
+          isProcessingStepQueue: true,
+        });
+      });
+
+      await act(async () => {
+        await result.current.internal_processStepUpdateQueue();
+      });
+
+      // userService.updateOnboarding should not be called
+      expect(userService.updateOnboarding).not.toHaveBeenCalled();
+    });
+
+    it('should not process when queue is empty', async () => {
+      const { result } = renderHook(() => useUserStore());
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          stepUpdateQueue: [],
+          isProcessingStepQueue: false,
+        });
+      });
+
+      await act(async () => {
+        await result.current.internal_processStepUpdateQueue();
+      });
+
+      expect(userService.updateOnboarding).not.toHaveBeenCalled();
+    });
+
+    it('should process queue and call userService.updateOnboarding', async () => {
+      const { result } = renderHook(() => useUserStore());
+
+      vi.mocked(userService.updateOnboarding).mockResolvedValue({} as any);
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          stepUpdateQueue: [2],
+          isProcessingStepQueue: false,
+          onboarding: { version: CURRENT_ONBOARDING_VERSION },
+          refreshUserState: vi.fn(),
+        });
+      });
+
+      await act(async () => {
+        await result.current.internal_processStepUpdateQueue();
+      });
+
+      expect(userService.updateOnboarding).toHaveBeenCalledWith({
+        currentStep: 2,
+        finishedAt: undefined,
+        version: CURRENT_ONBOARDING_VERSION,
+      });
+    });
+
+    it('should handle errors gracefully and continue processing', async () => {
+      const { result } = renderHook(() => useUserStore());
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      vi.mocked(userService.updateOnboarding).mockRejectedValueOnce(new Error('Update failed'));
+
+      act(() => {
+        useUserStore.setState({
+          ...initialOnboardingState,
+          stepUpdateQueue: [2],
+          isProcessingStepQueue: false,
+          onboarding: { version: CURRENT_ONBOARDING_VERSION },
+          refreshUserState: vi.fn(),
+        });
+      });
+
+      await act(async () => {
+        await result.current.internal_processStepUpdateQueue();
+      });
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'Failed to update onboarding step:',
+        expect.any(Error),
+      );
+      expect(result.current.isProcessingStepQueue).toBe(false);
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+});

package/src/store/user/slices/onboarding/action.ts

@@ -1,4 +1,5 @@
 import { CURRENT_ONBOARDING_VERSION, INBOX_SESSION_ID } from '@lobechat/const';
+import { MAX_ONBOARDING_STEPS } from '@lobechat/types';
 import type { StateCreator } from 'zustand/vanilla';
 
 import { userService } from '@/services/user';
@@ -51,25 +52,19 @@ export const createOnboardingSlice: StateCreator<
 
   goToNextStep: () => {
     const currentStep = onboardingSelectors.currentStep(get());
-    const nextStep = currentStep + 1;
+    if (currentStep === MAX_ONBOARDING_STEPS) return;
 
-    // Optimistic update: immediately update local state
+    const nextStep = currentStep + 1;
     set({ localOnboardingStep: nextStep }, false, 'goToNextStep/optimistic');
-
-    // Queue the server update
     get().internal_queueStepUpdate(nextStep);
   },
 
   goToPreviousStep: () => {
     const currentStep = onboardingSelectors.currentStep(get());
-    if (currentStep <= 1) return;
+    if (currentStep === 1) return;
 
     const prevStep = currentStep - 1;
-
-    // Optimistic update: immediately update local state
     set({ localOnboardingStep: prevStep }, false, 'goToPreviousStep/optimistic');
-
-    // Queue the server update
     get().internal_queueStepUpdate(prevStep);
   },